diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ea2239b..cf146a3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -27,47 +27,39 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        scala: [3.2.1, 2.13.10, 2.12.17]
-        java: [temurin@11]
+        scala: [3.3.7, 2.13.18, 2.12.21]
+        java: [zulu@8]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout current branch (full)
-        uses: actions/checkout@v2
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
-      - name: Setup Java (temurin@11)
-        if: matrix.java == 'temurin@11'
-        uses: actions/setup-java@v2
+      - name: Setup Java (zulu@8)
+        if: matrix.java == 'zulu@8'
+        uses: actions/setup-java@v5
         with:
-          distribution: temurin
-          java-version: 11
+          distribution: zulu
+          java-version: 8
+          cache: sbt
 
-      - name: Cache sbt
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.sbt
-            ~/.ivy2/cache
-            ~/.coursier/cache/v1
-            ~/.cache/coursier/v1
-            ~/AppData/Local/Coursier/Cache/v1
-            ~/Library/Caches/Coursier/v1
-          key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }}
+      - name: Setup sbt
+        uses: sbt/setup-sbt@v1
 
       - name: Check that workflows are up to date
-        run: sbt ++${{ matrix.scala }} githubWorkflowCheck
+        run: sbt '++ ${{ matrix.scala }}' githubWorkflowCheck
 
       - name: Build project
-        run: sbt ++${{ matrix.scala }} test
+        run: sbt '++ ${{ matrix.scala }}' test
 
-      - run: sbt ++${{ matrix.scala }} versionPolicyCheck test
+      - run: sbt '++ ${{ matrix.scala }}' versionPolicyCheck test
 
       - name: Compress target directories
-        run: tar cf targets.tar modules/apply/.js/target target modules/apply/.jvm/target modules/full/.js/target modules/full/.jvm/target modules/basic/.js/target modules/basic-light/.jvm/target modules/basic/.jvm/target modules/full-light/.js/target modules/basic-light/.js/target modules/full-light/.jvm/target project/target
+        run: tar cf targets.tar modules/apply/.js/target target modules/apply/.jvm/target modules/full/.js/target modules/full/.jvm/target modules/shared/.js/target modules/shared/.jvm/target modules/basic/.js/target modules/basic-light/.jvm/target modules/basic/.jvm/target modules/full-light/.js/target modules/basic-light/.js/target modules/full-light/.jvm/target project/target
 
       - name: Upload target directories
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v5
         with:
           name: target-${{ matrix.os }}-${{ matrix.scala }}-${{ matrix.java }}
           path: targets.tar
@@ -79,62 +71,54 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        scala: [2.13.10]
-        java: [temurin@11]
+        scala: [3.3.7]
+        java: [zulu@8]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout current branch (full)
-        uses: actions/checkout@v2
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
-      - name: Setup Java (temurin@11)
-        if: matrix.java == 'temurin@11'
-        uses: actions/setup-java@v2
+      - name: Setup Java (zulu@8)
+        if: matrix.java == 'zulu@8'
+        uses: actions/setup-java@v5
         with:
-          distribution: temurin
-          java-version: 11
+          distribution: zulu
+          java-version: 8
+          cache: sbt
 
-      - name: Cache sbt
-        uses: actions/cache@v2
-        with:
-          path: |
-            ~/.sbt
-            ~/.ivy2/cache
-            ~/.coursier/cache/v1
-            ~/.cache/coursier/v1
-            ~/AppData/Local/Coursier/Cache/v1
-            ~/Library/Caches/Coursier/v1
-          key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }}
-
-      - name: Download target directories (3.2.1)
-        uses: actions/download-artifact@v2
+      - name: Setup sbt
+        uses: sbt/setup-sbt@v1
+
+      - name: Download target directories (3.3.7)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-3.2.1-${{ matrix.java }}
+          name: target-${{ matrix.os }}-3.3.7-${{ matrix.java }}
 
-      - name: Inflate target directories (3.2.1)
+      - name: Inflate target directories (3.3.7)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.13.10)
-        uses: actions/download-artifact@v2
+      - name: Download target directories (2.13.18)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-2.13.10-${{ matrix.java }}
+          name: target-${{ matrix.os }}-2.13.18-${{ matrix.java }}
 
-      - name: Inflate target directories (2.13.10)
+      - name: Inflate target directories (2.13.18)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - name: Download target directories (2.12.17)
-        uses: actions/download-artifact@v2
+      - name: Download target directories (2.12.21)
+        uses: actions/download-artifact@v6
         with:
-          name: target-${{ matrix.os }}-2.12.17-${{ matrix.java }}
+          name: target-${{ matrix.os }}-2.12.21-${{ matrix.java }}
 
-      - name: Inflate target directories (2.12.17)
+      - name: Inflate target directories (2.12.21)
         run: |
           tar xf targets.tar
           rm targets.tar
 
-      - run: sbt ++${{ matrix.scala }} ci-release
+      - run: sbt ci-release
diff --git a/.github/workflows/clean.yml b/.github/workflows/clean.yml
index 547aaa4..4bb28c8 100644
--- a/.github/workflows/clean.yml
+++ b/.github/workflows/clean.yml
@@ -9,6 +9,9 @@ name: Clean
 
 on: push
 
+permissions:
+  actions: write
+
 jobs:
   delete-artifacts:
     name: Delete Artifacts
@@ -17,6 +20,7 @@ jobs:
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
       - name: Delete artifacts
+        shell: bash {0}
         run: |
           # Customize those three lines with your repository and credentials:
           REPO=${GITHUB_API_URL}/repos/${{ github.repository }}
@@ -25,7 +29,7 @@ jobs:
           ghapi() { curl --silent --location --user _:$GITHUB_TOKEN "$@"; }
 
           # A temporary file which receives HTTP response headers.
-          TMPFILE=/tmp/tmp.$$
+          TMPFILE=$(mktemp)
 
           # An associative array, key: artifact name, value: number of artifacts of that name.
           declare -A ARTCOUNT
diff --git a/build.sbt b/build.sbt
index af08693..85c29ee 100644
--- a/build.sbt
+++ b/build.sbt
@@ -1,5 +1,6 @@
 import sbt.librarymanagement.CrossVersion
-import com.typesafe.tools.mima.core._
+import com.typesafe.tools.mima.core.*
+import org.typelevel.scalacoptions.{ ScalacOption, ScalacOptions }
 
 inThisBuild(
   List(
@@ -9,7 +10,7 @@ inThisBuild(
     developers               := List(Developer("yurique", "Iurii Malchenko", "i@yurique.com", url("https://github.com/yurique"))),
     scmInfo                  := Some(ScmInfo(url("https://github.com/tulz-app/tuplez"), "scm:git@github.com/tulz-app/tuplez.git")),
     (Test / publishArtifact) := false,
-    scalaVersion             := ScalaVersions.v213,
+    scalaVersion             := ScalaVersions.v3,
     crossScalaVersions := Seq(
       ScalaVersions.v3,
       ScalaVersions.v213,
@@ -34,104 +35,131 @@ inThisBuild(
   )
 )
 
+// scala3-only implementation without codegen
+lazy val `tuplez-shared` =
+  crossProject(JVMPlatform, JSPlatform)
+    .crossType(CrossType.Pure)
+    .in(file("modules/shared"))
+    .settings(commonSettings)
+    .jsSettings(commonJsSettings)
+    .settings(
+      name := "tuplez-shared",
+      description := "Scala tuple composition, shared module with Scala 3 implementation."
+    )
+
 lazy val `tuplez-full` =
   crossProject(JVMPlatform, JSPlatform)
     .crossType(CrossType.Pure)
     .in(file("modules/full"))
     .jsConfigure(_.enablePlugins(ScalaJSJUnitPlugin))
-    .settings(ScalaOptions.fixOptions)
     .settings(commonSettings)
     .jsSettings(commonJsSettings)
     .settings(
       name := "tuplez-full",
       Compile / sourceGenerators += Def.task {
-        Seq.concat(
-          new TupleCompositionGenerator((Compile / sharedScalaSource).value, to = 22, generateConcats = true, generatePrepends = true).generate()
-        )
+        CrossVersion.partialVersion(scalaVersion.value) match {
+          case Some((2, _)) =>
+            new TupleCompositionGenerator((Compile / sharedScala2Source).value, to = 22, splitPriorityAt = 6, generateConcats = true, generatePrepends = true).generate()
+          case Some((3, _)) =>
+            Seq.empty
+          case _ => Seq.empty
+        }
       }.taskValue,
       Test / sourceGenerators += Def.task {
         Seq.concat(
-          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 22, testConcats = true, testPrepends = true).generate()
+          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 22, testConcats = true, testPrepends = true, scala3 = CrossVersion.partialVersion(scalaVersion.value).exists(_._1 == 3)).generate()
         )
       }.taskValue,
       description := "Scala tuple composition."
     )
+    .dependsOn(`tuplez-shared`)
 
 lazy val `tuplez-full-light` =
   crossProject(JVMPlatform, JSPlatform)
     .crossType(CrossType.Pure)
     .in(file("modules/full-light"))
     .jsConfigure(_.enablePlugins(ScalaJSJUnitPlugin))
-    .settings(ScalaOptions.fixOptions)
     .settings(commonSettings)
     .jsSettings(commonJsSettings)
     .settings(
       name := "tuplez-full-light",
       Compile / sourceGenerators += Def.task {
-        Seq.concat(
-          new TupleCompositionGenerator((Compile / sharedScalaSource).value, to = 10, generateConcats = true, generatePrepends = true).generate()
-        )
+        CrossVersion.partialVersion(scalaVersion.value) match {
+          case Some((2, _)) =>
+            new TupleCompositionGenerator((Compile / sharedScala2Source).value, to = 10, splitPriorityAt = 6, generateConcats = true, generatePrepends = true).generate()
+          case Some((3, _)) =>
+            Seq.empty
+          case _ => Seq.empty
+        }
       }.taskValue,
       Test / sourceGenerators += Def.task {
         Seq.concat(
-          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 10, testConcats = true, testPrepends = true).generate()
+          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 10, testConcats = true, testPrepends = true, scala3 = CrossVersion.partialVersion(scalaVersion.value).exists(_._1 == 3)).generate()
         )
       }.taskValue,
       description := "Scala tuple composition."
     )
+    .dependsOn(`tuplez-shared`)
 
 lazy val `tuplez-basic` =
   crossProject(JVMPlatform, JSPlatform)
     .crossType(CrossType.Pure)
     .in(file("modules/basic"))
     .jsConfigure(_.enablePlugins(ScalaJSJUnitPlugin))
-    .settings(ScalaOptions.fixOptions)
     .settings(commonSettings)
     .jsSettings(commonJsSettings)
     .settings(
       name := "tuplez-basic",
       Compile / sourceGenerators += Def.task {
-        Seq.concat(
-          new TupleCompositionGenerator((Compile / sharedScalaSource).value, to = 22, generateConcats = false, generatePrepends = false).generate()
-        )
+        CrossVersion.partialVersion(scalaVersion.value) match {
+          case Some((2, _)) =>
+            new TupleCompositionGenerator((Compile / sharedScala2Source).value, to = 22, splitPriorityAt = 6, generateConcats = false, generatePrepends = false).generate()
+          case Some((3, _)) =>
+            Seq.empty
+          case _ => Seq.empty
+        }
       }.taskValue,
       Test / sourceGenerators += Def.task {
         Seq.concat(
-          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 22, testConcats = false, testPrepends = false).generate()
+          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 22, testConcats = false, testPrepends = false, scala3 = CrossVersion.partialVersion(scalaVersion.value).exists(_._1 == 3)).generate()
         )
       }.taskValue,
       description := "Scala tuple composition."
     )
+    .dependsOn(`tuplez-shared`)
 
 lazy val `tuplez-basic-light` =
   crossProject(JVMPlatform, JSPlatform)
     .crossType(CrossType.Pure)
     .in(file("modules/basic-light"))
     .jsConfigure(_.enablePlugins(ScalaJSJUnitPlugin))
-    .settings(ScalaOptions.fixOptions)
     .settings(commonSettings)
     .jsSettings(commonJsSettings)
     .settings(
       name := "tuplez-basic-light",
       Compile / sourceGenerators += Def.task {
-        Seq.concat(
-          new TupleCompositionGenerator((Compile / sharedScalaSource).value, to = 10, generateConcats = false, generatePrepends = false).generate()
-        )
+        CrossVersion.partialVersion(scalaVersion.value) match {
+          case Some((2, _)) =>
+            new TupleCompositionGenerator((Compile / sharedScala2Source).value, to = 10, splitPriorityAt = 6, generateConcats = false, generatePrepends = false).generate()
+          case Some((3, _)) =>
+            Seq.empty
+          case _ => Seq.empty
+        }
       }.taskValue,
       Test / sourceGenerators += Def.task {
         Seq.concat(
-          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 10, testConcats = false, testPrepends = false).generate()
+          new TupleCompositionTestGenerator((Test / sourceManaged).value, to = 10, testConcats = false, testPrepends = false, scala3 = CrossVersion.partialVersion(scalaVersion.value).exists(_._1 == 3)).generate()
         )
       }.taskValue,
       description := "Scala tuple composition."
     )
+    .dependsOn(`tuplez-shared`)
 
 lazy val `tuplez-apply` =
   crossProject(JVMPlatform, JSPlatform)
     .crossType(CrossType.Pure)
     .in(file("modules/apply"))
     .jsConfigure(_.enablePlugins(ScalaJSJUnitPlugin))
-    .settings(ScalaOptions.fixOptions)
     .settings(commonSettings)
     .jsSettings(commonJsSettings)
     .settings(
@@ -156,7 +184,8 @@ lazy val commonSettings = Seq(
     ("com.github.sbt" % "junit-interface" % "0.13.3" % Test).exclude("junit", "junit-dep")
   ),
   scalacOptions := scalacOptions.value.filterNot(_ == "-Wdead-code"),
-//  scalacOptions := scalacOptions.value.filterNot(_ == "-Xfatal-warnings")
+  Test / scalacOptions += "-Wconf:msg=a type was inferred to be `Any`:s",
+  tpolecatScalacOptions += ScalacOptions.explain
 )
 
 lazy val commonJsSettings = Seq(
@@ -188,6 +217,8 @@ lazy val root = project
   )
   .settings(noPublish)
   .aggregate(
+    `tuplez-shared`.js,
+    `tuplez-shared`.jvm,
     `tuplez-full`.js,
     `tuplez-full-light`.js,
     `tuplez-basic`.js,
diff --git a/modules/basic-light/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala b/modules/basic-light/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
new file mode 100644
index 0000000..a95f7df
--- /dev/null
+++ b/modules/basic-light/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
@@ -0,0 +1,591 @@
+package app.tulz.tuplez
+
+object TupleComposition {
+
+  def compose[L, R](l: L, r: R)(implicit composition: Compose[L, R]): composition.Composed = composition.compose(l, r)
+  def decompose[L, R, C](c: C)(implicit composition: Decompose.Aux[L, R, C]): (L, R)       = composition.decompose(c)
+
+}
+
+trait Compose[-L, -R] {
+  type Composed
+  def compose(a: L, b: R): Composed
+}
+
+trait Decompose[L, R] {
+  type Composed
+  def decompose(c: Composed): (L, R)
+}
+
+abstract class Composition[L, R] extends Compose[L, R] with Decompose[L, R] {
+  type Composed
+}
+
+trait Compose_Pri0 {
+  implicit def `***`[A, B]: Compose.Aux[A, B, Tuple2[A, B]] = new Compose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
+    def compose(l: A, r: B): Tuple2[A, B] =
+      Tuple2(l, r)
+    
+  }
+}
+
+trait Decompose_Pri0 {
+  implicit def `***`[A, B]: Decompose.Aux[A, B, Tuple2[A, B]] = new Decompose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
+    def decompose(c: Tuple2[A, B]): (A, B) =
+      c
+    
+  }
+}
+
+trait Compose_Pri5 extends Compose_Pri0 {
+  implicit def `T1+R`[L, R]: Compose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Compose[Tuple1[L], R] {
+
+    override type Composed = Tuple2[L, R]
+
+    def compose(l: Tuple1[L], r: R): Tuple2[L, R] =
+      Tuple2(l._1, r)
+    
+  }
+  implicit def `L+T1`[L, R]: Compose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Compose[L, Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def compose(l: L, r: Tuple1[R]): Tuple2[L, R] =
+      Tuple2(l, r._1)
+    
+  }
+}
+
+trait Decompose_Pri5 extends Decompose_Pri0 {
+  implicit def `T1+R`[L, R]: Decompose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Decompose[Tuple1[L], R] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
+      Tuple2(Tuple1(c._1), c._2)
+    
+  }
+  implicit def `L+T1`[L, R]: Decompose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Decompose[L, Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (L, Tuple1[R]) =
+      Tuple2(c._1, Tuple1(c._2))
+    
+  }
+}
+
+trait Compose_Pri6 extends Compose_Pri5 {
+
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6), r: R): (T1, T2, T3, T4, T5, T6, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r)
+    
+  }
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: R): (T1, T2, T3, T4, T5, T6, T7, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r)
+    
+  }
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r)
+    
+  }
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r)
+    
+  }
+}
+
+trait Compose_Pri7 extends Compose_Pri6 {
+
+  implicit def `T2+scalar`[T1, T2, R]: Compose.Aux[(T1, T2), R, (T1, T2, R)] = new Compose[(T1, T2), R] {
+
+    override type Composed = (T1, T2, R)
+
+    def compose(l: (T1, T2), r: R): (T1, T2, R) =
+      (l._1, l._2, r)
+    
+  }
+  implicit def `T3+scalar`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Compose[(T1, T2, T3), R] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def compose(l: (T1, T2, T3), r: R): (T1, T2, T3, R) =
+      (l._1, l._2, l._3, r)
+    
+  }
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), R] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def compose(l: (T1, T2, T3, T4), r: R): (T1, T2, T3, T4, R) =
+      (l._1, l._2, l._3, l._4, r)
+    
+  }
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def compose(l: (T1, T2, T3, T4, T5), r: R): (T1, T2, T3, T4, T5, R) =
+      (l._1, l._2, l._3, l._4, l._5, r)
+    
+  }
+}
+
+trait Decompose_Pri6 extends Decompose_Pri5 {
+
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), c._7)
+    
+  }
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), c._8)
+    
+  }
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), c._9)
+    
+  }
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), c._10)
+    
+  }
+}
+
+trait Decompose_Pri7 extends Decompose_Pri6 {
+
+  implicit def `T2+scalar`[T1, T2, R]: Decompose.Aux[(T1, T2), R, (T1, T2, R)] = new Decompose[(T1, T2), R] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
+      ((c._1, c._2), c._3)
+    
+  }
+  implicit def `T3+scalar`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), R] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
+      ((c._1, c._2, c._3), c._4)
+    
+  }
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), R] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
+      ((c._1, c._2, c._3, c._4), c._5)
+    
+  }
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
+      ((c._1, c._2, c._3, c._4, c._5), c._6)
+    
+  }
+}
+
+trait Compose_Pri9 extends Compose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
+    
+  }
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
+    
+  }
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
+    
+  }
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
+    
+  }
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+}
+
+trait Compose_Pri10 extends Compose_Pri9 {
+
+  implicit def `T1+T1`[L, R]: Compose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Compose[Tuple1[L], Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def compose(l: Tuple1[L], r: Tuple1[R]): Tuple2[L, R] =
+      (l._1, r._1)
+    
+  }
+
+  implicit def `T2+T1`[T1, T2, R]: Compose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Compose[(T1, T2), Tuple1[R]] {
+
+    override type Composed = (T1, T2, R)
+
+    def compose(l: (T1, T2), r: Tuple1[R]): (T1, T2, R) =
+      (l._1, l._2, r._1)
+    
+  }
+  implicit def `T1+T2`[L, T1, T2]: Compose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Compose[Tuple1[L], (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def compose(l: Tuple1[L], r: (T1, T2)): (L, T1, T2) =
+      (l._1, r._1, r._2)
+    
+  }
+  implicit def `T3+T1`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Compose[(T1, T2, T3), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def compose(l: (T1, T2, T3), r: Tuple1[R]): (T1, T2, T3, R) =
+      (l._1, l._2, l._3, r._1)
+    
+  }
+  implicit def `T1+T3`[L, T1, T2, T3]: Compose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Compose[Tuple1[L], (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3)): (L, T1, T2, T3) =
+      (l._1, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def compose(l: (T1, T2, T3, T4), r: Tuple1[R]): (T1, T2, T3, T4, R) =
+      (l._1, l._2, l._3, l._4, r._1)
+    
+  }
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Compose[Tuple1[L], (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
+      (l._1, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def compose(l: (T1, T2, T3, T4, T5), r: Tuple1[R]): (T1, T2, T3, T4, T5, R) =
+      (l._1, l._2, l._3, l._4, l._5, r._1)
+    
+  }
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
+      (l._1, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `unit+A`[A]: Compose.Aux[Unit, A, A] = new Compose[Unit, A] {
+
+    override type Composed = A
+
+    def compose(l: Unit, r: A): A =
+      r
+    
+  }
+  implicit def `A+unit`[A]: Compose.Aux[A, Unit, A] = new Compose[A, Unit] {
+
+    override type Composed = A
+
+    def compose(l: A, r: Unit): A =
+      l
+    
+  }
+
+}
+
+trait Decompose_Pri9 extends Decompose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), Tuple1(c._7))
+    
+  }
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (Tuple1[L], (T1, T2, T3, T4, T5, T6)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7))
+    
+  }
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), Tuple1(c._8))
+    
+  }
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
+    
+  }
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), Tuple1(c._9))
+    
+  }
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), Tuple1(c._10))
+    
+  }
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
+    
+  }
+}
+
+trait Decompose_Pri10 extends Decompose_Pri9 {
+
+  implicit def `T1+T1`[L, R]: Decompose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Decompose[Tuple1[L], Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
+      (Tuple1(c._1), Tuple1(c._2))
+    
+  }
+
+  implicit def `T2+T1`[T1, T2, R]: Decompose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Decompose[(T1, T2), Tuple1[R]] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
+      ((c._1, c._2), Tuple1(c._3))
+    
+  }
+  implicit def `T1+T2`[L, T1, T2]: Decompose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Decompose[Tuple1[L], (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
+      (Tuple1(c._1), (c._2, c._3))
+    
+  }
+  implicit def `T3+T1`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
+      ((c._1, c._2, c._3), Tuple1(c._4))
+    
+  }
+  implicit def `T1+T3`[L, T1, T2, T3]: Decompose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Decompose[Tuple1[L], (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
+      (Tuple1(c._1), (c._2, c._3, c._4))
+    
+  }
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
+    
+  }
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Decompose[Tuple1[L], (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
+    
+  }
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
+    
+  }
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
+    
+  }
+  implicit def `unit+A`[A]: Decompose.Aux[Unit, A, A] = new Decompose[Unit, A] {
+
+    override type Composed = A
+
+    def decompose(c: A): (Unit, A) =
+      ((), c)
+    
+  }
+  implicit def `A+unit`[A]: Decompose.Aux[A, Unit, A] = new Decompose[A, Unit] {
+
+    override type Composed = A
+
+    def decompose(c: A): (A, Unit) =
+      (c, ())
+    
+  }
+
+}
+
+object Compose extends Compose_Pri10 {
+  type Aux[A, B, O] = Compose[A, B] { type Composed = O }
+
+  implicit def `unit+unit`: Compose.Aux[Unit, Unit, Unit] = new Compose[Unit, Unit] {
+
+    override type Composed = Unit
+
+    def compose(l: Unit, r: Unit): Unit =
+      ()
+    
+  }
+
+}
+
+object Decompose extends Decompose_Pri10 {
+  type Aux[A, B, O] = Decompose[A, B] { type Composed = O }
+
+  implicit def `unit+unit`: Decompose.Aux[Unit, Unit, Unit] = new Decompose[Unit, Unit] {
+
+    override type Composed = Unit
+
+    def decompose(c: Unit): (Unit, Unit) =
+      ((), ())
+    
+  }
+
+}
+
+object Composition {
+  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
+
+  implicit def implied[A, B, O](implicit c: Compose.Aux[A, B, O], d: Decompose.Aux[A, B, O]): Composition.Aux[A, B, O] = {
+    new Composition[A, B] {
+      override type Composed = O
+
+      def compose(l: A, r: B): O = c.compose(l, r)
+      def decompose(c: O): (A, B) = d.decompose(c)
+    }
+  }
+}
diff --git a/modules/basic-light/src/main/scala/app/tulz/tuplez/TupleComposition.scala b/modules/basic-light/src/main/scala/app/tulz/tuplez/TupleComposition.scala
deleted file mode 100644
index 9673032..0000000
--- a/modules/basic-light/src/main/scala/app/tulz/tuplez/TupleComposition.scala
+++ /dev/null
@@ -1,377 +0,0 @@
-package app.tulz.tuplez
-
-object TupleComposition {
-
-  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)
-  def decompose[L, R, C](c: C)(implicit composition: Composition.Aux[L, R, C]): (L, R)         = composition.decompose(c)
-
-}
-
-abstract class Composition[L, R] {
-  type Composed
-  def compose(a: L, b: R): Composed
-  def decompose(c: Composed): (L, R)
-}
-
-trait Composition_Pri0 {
-  implicit def `***`[A, B]: Composition.Aux[A, B, Tuple2[A, B]] = new Composition[A, B] {
-
-    override type Composed = Tuple2[A, B]
-
-    def compose(l: A, r: B): Tuple2[A, B] =
-      Tuple2(l, r)
-    
-    def decompose(c: Tuple2[A, B]): (A, B) =
-      c
-    
-  }
-}
-
-trait Composition_Pri5 extends Composition_Pri0{
-  implicit def `T1+R`[L, R]: Composition.Aux[Tuple1[L], R, Tuple2[L, R]] = new Composition[Tuple1[L], R] {
-
-    override type Composed = Tuple2[L, R]
-
-    def compose(l: Tuple1[L], r: R): Tuple2[L, R] =
-      Tuple2(l._1, r)
-    
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
-      Tuple2(Tuple1(c._1), c._2)
-    
-  }
-  implicit def `L+T1`[L, R]: Composition.Aux[L, Tuple1[R], Tuple2[L, R]] = new Composition[L, Tuple1[R]] {
-
-    override type Composed = Tuple2[L, R]
-
-    def compose(l: L, r: Tuple1[R]): Tuple2[L, R] =
-      Tuple2(l, r._1)
-    
-    def decompose(c: Tuple2[L, R]): (L, Tuple1[R]) =
-      Tuple2(c._1, Tuple1(c._2))
-    
-  }
-}
-
-trait Composition_Pri7 extends Composition_Pri5 {
-
-  implicit def `T2+scalar`[T1, T2, R]: Composition.Aux[(T1, T2), R, (T1, T2, R)] = new Composition[(T1, T2), R] {
-
-    override type Composed = (T1, T2, R)
-
-    def compose(l: (T1, T2), r: R): (T1, T2, R) =
-      (l._1, l._2, r)
-    
-    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
-      ((c._1, c._2), c._3)
-    
-  }
-  implicit def `T3+scalar`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Composition[(T1, T2, T3), R] {
-
-    override type Composed = (T1, T2, T3, R)
-
-    def compose(l: (T1, T2, T3), r: R): (T1, T2, T3, R) =
-      (l._1, l._2, l._3, r)
-    
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
-      ((c._1, c._2, c._3), c._4)
-    
-  }
-  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), R] {
-
-    override type Composed = (T1, T2, T3, T4, R)
-
-    def compose(l: (T1, T2, T3, T4), r: R): (T1, T2, T3, T4, R) =
-      (l._1, l._2, l._3, l._4, r)
-    
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
-      ((c._1, c._2, c._3, c._4), c._5)
-    
-  }
-  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, R)
-
-    def compose(l: (T1, T2, T3, T4, T5), r: R): (T1, T2, T3, T4, T5, R) =
-      (l._1, l._2, l._3, l._4, l._5, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
-      ((c._1, c._2, c._3, c._4, c._5), c._6)
-    
-  }
-  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6), r: R): (T1, T2, T3, T4, T5, T6, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), c._7)
-    
-  }
-  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: R): (T1, T2, T3, T4, T5, T6, T7, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), c._8)
-    
-  }
-  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), c._9)
-    
-  }
-  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), c._10)
-    
-  }
-}
-
-trait Composition_Pri10 extends Composition_Pri7 {
-
-  implicit def `T1+T1`[L, R]: Composition.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Composition[Tuple1[L], Tuple1[R]] {
-
-    override type Composed = Tuple2[L, R]
-
-    def compose(l: Tuple1[L], r: Tuple1[R]): Tuple2[L, R] =
-      (l._1, r._1)
-    
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
-      (Tuple1(c._1), Tuple1(c._2))
-    
-  }
-
-  implicit def `T2+T1`[T1, T2, R]: Composition.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Composition[(T1, T2), Tuple1[R]] {
-
-    override type Composed = (T1, T2, R)
-
-    def compose(l: (T1, T2), r: Tuple1[R]): (T1, T2, R) =
-      (l._1, l._2, r._1)
-    
-    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
-      ((c._1, c._2), Tuple1(c._3))
-    
-  }
-  implicit def `T1+T2`[L, T1, T2]: Composition.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Composition[Tuple1[L], (T1, T2)] {
-
-    override type Composed = (L, T1, T2)
-
-    def compose(l: Tuple1[L], r: (T1, T2)): (L, T1, T2) =
-      (l._1, r._1, r._2)
-    
-    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
-      (Tuple1(c._1), (c._2, c._3))
-    
-  }
-  implicit def `T3+T1`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Composition[(T1, T2, T3), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, R)
-
-    def compose(l: (T1, T2, T3), r: Tuple1[R]): (T1, T2, T3, R) =
-      (l._1, l._2, l._3, r._1)
-    
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
-      ((c._1, c._2, c._3), Tuple1(c._4))
-    
-  }
-  implicit def `T1+T3`[L, T1, T2, T3]: Composition.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Composition[Tuple1[L], (T1, T2, T3)] {
-
-    override type Composed = (L, T1, T2, T3)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3)): (L, T1, T2, T3) =
-      (l._1, r._1, r._2, r._3)
-    
-    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
-      (Tuple1(c._1), (c._2, c._3, c._4))
-    
-  }
-  implicit def `T4+T1`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, R)
-
-    def compose(l: (T1, T2, T3, T4), r: Tuple1[R]): (T1, T2, T3, T4, R) =
-      (l._1, l._2, l._3, l._4, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
-    
-  }
-  implicit def `T1+T4`[L, T1, T2, T3, T4]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Composition[Tuple1[L], (T1, T2, T3, T4)] {
-
-    override type Composed = (L, T1, T2, T3, T4)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
-      (l._1, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
-    
-  }
-  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, R)
-
-    def compose(l: (T1, T2, T3, T4, T5), r: Tuple1[R]): (T1, T2, T3, T4, T5, R) =
-      (l._1, l._2, l._3, l._4, l._5, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
-    
-  }
-  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
-      (l._1, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
-    
-  }
-  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), Tuple1(c._7))
-    
-  }
-  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (Tuple1[L], (T1, T2, T3, T4, T5, T6)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7))
-    
-  }
-  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), Tuple1(c._8))
-    
-  }
-  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
-    
-  }
-  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), Tuple1(c._9))
-    
-  }
-  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
-    
-  }
-  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), Tuple1(c._10))
-    
-  }
-  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
-    
-  }
-  implicit def `unit+A`[A]: Composition.Aux[Unit, A, A] = new Composition[Unit, A] {
-
-    override type Composed = A
-
-    def compose(l: Unit, r: A): A =
-      r
-    
-    def decompose(c: A): (Unit, A) =
-      ((), c)
-    
-  }
-  implicit def `A+unit`[A]: Composition.Aux[A, Unit, A] = new Composition[A, Unit] {
-
-    override type Composed = A
-
-    def compose(l: A, r: Unit): A =
-      l
-    
-    def decompose(c: A): (A, Unit) =
-      (c, ())
-    
-  }
-
-}
-
-object Composition extends Composition_Pri10 {
-  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
-
-  implicit def `unit+unit`: Composition.Aux[Unit, Unit, Unit] = new Composition[Unit, Unit] {
-
-    override type Composed = Unit
-
-    def compose(l: Unit, r: Unit): Unit =
-      ()
-    
-    def decompose(c: Unit): (Unit, Unit) =
-      ((), ())
-    
-  }
-
-}
diff --git a/modules/basic/src/main/scala/app/tulz/tuplez/TupleComposition.scala b/modules/basic/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
similarity index 50%
rename from modules/basic/src/main/scala/app/tulz/tuplez/TupleComposition.scala
rename to modules/basic/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
index d66a909..1579cfa 100644
--- a/modules/basic/src/main/scala/app/tulz/tuplez/TupleComposition.scala
+++ b/modules/basic/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
@@ -2,752 +2,1122 @@ package app.tulz.tuplez
 
 object TupleComposition {
 
-  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)
-  def decompose[L, R, C](c: C)(implicit composition: Composition.Aux[L, R, C]): (L, R)         = composition.decompose(c)
+  def compose[L, R](l: L, r: R)(implicit composition: Compose[L, R]): composition.Composed = composition.compose(l, r)
+  def decompose[L, R, C](c: C)(implicit composition: Decompose.Aux[L, R, C]): (L, R)       = composition.decompose(c)
 
 }
 
-abstract class Composition[L, R] {
+trait Compose[-L, -R] {
   type Composed
   def compose(a: L, b: R): Composed
+}
+
+trait Decompose[L, R] {
+  type Composed
   def decompose(c: Composed): (L, R)
 }
 
-trait Composition_Pri0 {
-  implicit def `***`[A, B]: Composition.Aux[A, B, Tuple2[A, B]] = new Composition[A, B] {
+abstract class Composition[L, R] extends Compose[L, R] with Decompose[L, R] {
+  type Composed
+}
+
+trait Compose_Pri0 {
+  implicit def `***`[A, B]: Compose.Aux[A, B, Tuple2[A, B]] = new Compose[A, B] {
 
     override type Composed = Tuple2[A, B]
 
     def compose(l: A, r: B): Tuple2[A, B] =
       Tuple2(l, r)
     
+  }
+}
+
+trait Decompose_Pri0 {
+  implicit def `***`[A, B]: Decompose.Aux[A, B, Tuple2[A, B]] = new Decompose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
     def decompose(c: Tuple2[A, B]): (A, B) =
       c
     
   }
 }
 
-trait Composition_Pri5 extends Composition_Pri0{
-  implicit def `T1+R`[L, R]: Composition.Aux[Tuple1[L], R, Tuple2[L, R]] = new Composition[Tuple1[L], R] {
+trait Compose_Pri5 extends Compose_Pri0 {
+  implicit def `T1+R`[L, R]: Compose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Compose[Tuple1[L], R] {
 
     override type Composed = Tuple2[L, R]
 
     def compose(l: Tuple1[L], r: R): Tuple2[L, R] =
       Tuple2(l._1, r)
     
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
-      Tuple2(Tuple1(c._1), c._2)
-    
   }
-  implicit def `L+T1`[L, R]: Composition.Aux[L, Tuple1[R], Tuple2[L, R]] = new Composition[L, Tuple1[R]] {
+  implicit def `L+T1`[L, R]: Compose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Compose[L, Tuple1[R]] {
 
     override type Composed = Tuple2[L, R]
 
     def compose(l: L, r: Tuple1[R]): Tuple2[L, R] =
       Tuple2(l, r._1)
     
+  }
+}
+
+trait Decompose_Pri5 extends Decompose_Pri0 {
+  implicit def `T1+R`[L, R]: Decompose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Decompose[Tuple1[L], R] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
+      Tuple2(Tuple1(c._1), c._2)
+    
+  }
+  implicit def `L+T1`[L, R]: Decompose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Decompose[L, Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
     def decompose(c: Tuple2[L, R]): (L, Tuple1[R]) =
       Tuple2(c._1, Tuple1(c._2))
     
   }
 }
 
-trait Composition_Pri7 extends Composition_Pri5 {
+trait Compose_Pri6 extends Compose_Pri5 {
+
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6), r: R): (T1, T2, T3, T4, T5, T6, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r)
+    
+  }
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: R): (T1, T2, T3, T4, T5, T6, T7, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r)
+    
+  }
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r)
+    
+  }
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r)
+    
+  }
+  implicit def `T10+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r)
+    
+  }
+  implicit def `T11+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r)
+    
+  }
+  implicit def `T12+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r)
+    
+  }
+  implicit def `T13+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r)
+    
+  }
+  implicit def `T14+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r)
+    
+  }
+  implicit def `T15+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r)
+    
+  }
+  implicit def `T16+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r)
+    
+  }
+  implicit def `T17+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r)
+    
+  }
+  implicit def `T18+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r)
+    
+  }
+  implicit def `T19+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r)
+    
+  }
+  implicit def `T20+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r)
+    
+  }
+  implicit def `T21+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, l._21, r)
+    
+  }
+}
+
+trait Compose_Pri7 extends Compose_Pri6 {
 
-  implicit def `T2+scalar`[T1, T2, R]: Composition.Aux[(T1, T2), R, (T1, T2, R)] = new Composition[(T1, T2), R] {
+  implicit def `T2+scalar`[T1, T2, R]: Compose.Aux[(T1, T2), R, (T1, T2, R)] = new Compose[(T1, T2), R] {
 
     override type Composed = (T1, T2, R)
 
     def compose(l: (T1, T2), r: R): (T1, T2, R) =
       (l._1, l._2, r)
     
-    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
-      ((c._1, c._2), c._3)
-    
   }
-  implicit def `T3+scalar`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Composition[(T1, T2, T3), R] {
+  implicit def `T3+scalar`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Compose[(T1, T2, T3), R] {
 
     override type Composed = (T1, T2, T3, R)
 
     def compose(l: (T1, T2, T3), r: R): (T1, T2, T3, R) =
       (l._1, l._2, l._3, r)
     
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
-      ((c._1, c._2, c._3), c._4)
-    
   }
-  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), R] {
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), R] {
 
     override type Composed = (T1, T2, T3, T4, R)
 
     def compose(l: (T1, T2, T3, T4), r: R): (T1, T2, T3, T4, R) =
       (l._1, l._2, l._3, l._4, r)
     
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
-      ((c._1, c._2, c._3, c._4), c._5)
-    
   }
-  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), R] {
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, R)
 
     def compose(l: (T1, T2, T3, T4, T5), r: R): (T1, T2, T3, T4, T5, R) =
       (l._1, l._2, l._3, l._4, l._5, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
-      ((c._1, c._2, c._3, c._4, c._5), c._6)
-    
   }
-  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), R] {
+}
+
+trait Decompose_Pri6 extends Decompose_Pri5 {
+
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6), r: R): (T1, T2, T3, T4, T5, T6, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), c._7)
     
   }
-  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), R] {
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: R): (T1, T2, T3, T4, T5, T6, T7, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), c._8)
     
   }
-  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), c._9)
     
   }
-  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), c._10)
     
   }
-  implicit def `T10+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R] {
+  implicit def `T10+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), c._11)
     
   }
-  implicit def `T11+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R] {
+  implicit def `T11+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), c._12)
     
   }
-  implicit def `T12+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R] {
+  implicit def `T12+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), c._13)
     
   }
-  implicit def `T13+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R] {
+  implicit def `T13+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), c._14)
     
   }
-  implicit def `T14+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R] {
+  implicit def `T14+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), c._15)
     
   }
-  implicit def `T15+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R] {
+  implicit def `T15+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), c._16)
     
   }
-  implicit def `T16+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R] {
+  implicit def `T16+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), c._17)
     
   }
-  implicit def `T17+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R] {
+  implicit def `T17+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), c._18)
     
   }
-  implicit def `T18+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R] {
+  implicit def `T18+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), c._19)
     
   }
-  implicit def `T19+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R] {
+  implicit def `T19+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19), c._20)
     
   }
-  implicit def `T20+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R] {
+  implicit def `T20+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20), c._21)
+    
+  }
+  implicit def `T21+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21), c._22)
+    
+  }
+}
+
+trait Decompose_Pri7 extends Decompose_Pri6 {
+
+  implicit def `T2+scalar`[T1, T2, R]: Decompose.Aux[(T1, T2), R, (T1, T2, R)] = new Decompose[(T1, T2), R] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
+      ((c._1, c._2), c._3)
+    
+  }
+  implicit def `T3+scalar`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), R] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
+      ((c._1, c._2, c._3), c._4)
+    
+  }
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), R] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
+      ((c._1, c._2, c._3, c._4), c._5)
+    
+  }
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
+      ((c._1, c._2, c._3, c._4, c._5), c._6)
+    
+  }
+}
+
+trait Compose_Pri9 extends Compose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
+    
+  }
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
+    
+  }
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
+    
+  }
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
+    
+  }
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T10+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1)
+    
+  }
+  implicit def `T1+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T11+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1)
+    
+  }
+  implicit def `T1+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T12+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1)
+    
+  }
+  implicit def `T1+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T13+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1)
+    
+  }
+  implicit def `T1+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T14+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1)
+    
+  }
+  implicit def `T1+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T15+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1)
+    
+  }
+  implicit def `T1+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T16+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1)
+    
+  }
+  implicit def `T1+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
+    
+  }
+  implicit def `T17+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1)
+    
+  }
+  implicit def `T1+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
+    
+  }
+  implicit def `T18+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1)
+    
+  }
+  implicit def `T1+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
+    
+  }
+  implicit def `T19+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1)
+    
+  }
+  implicit def `T1+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
+    
+  }
+  implicit def `T20+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r)
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r._1)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20), c._21)
+  }
+  implicit def `T1+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20)
     
   }
-  implicit def `T21+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R] {
+  implicit def `T21+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, l._21, r)
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, l._21, r._1)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21), c._22)
+  }
+  implicit def `T1+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20, r._21)
     
   }
 }
 
-trait Composition_Pri10 extends Composition_Pri7 {
+trait Compose_Pri10 extends Compose_Pri9 {
 
-  implicit def `T1+T1`[L, R]: Composition.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Composition[Tuple1[L], Tuple1[R]] {
+  implicit def `T1+T1`[L, R]: Compose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Compose[Tuple1[L], Tuple1[R]] {
 
     override type Composed = Tuple2[L, R]
 
     def compose(l: Tuple1[L], r: Tuple1[R]): Tuple2[L, R] =
       (l._1, r._1)
     
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
-      (Tuple1(c._1), Tuple1(c._2))
-    
   }
 
-  implicit def `T2+T1`[T1, T2, R]: Composition.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Composition[(T1, T2), Tuple1[R]] {
+  implicit def `T2+T1`[T1, T2, R]: Compose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Compose[(T1, T2), Tuple1[R]] {
 
     override type Composed = (T1, T2, R)
 
     def compose(l: (T1, T2), r: Tuple1[R]): (T1, T2, R) =
       (l._1, l._2, r._1)
     
-    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
-      ((c._1, c._2), Tuple1(c._3))
-    
   }
-  implicit def `T1+T2`[L, T1, T2]: Composition.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Composition[Tuple1[L], (T1, T2)] {
+  implicit def `T1+T2`[L, T1, T2]: Compose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Compose[Tuple1[L], (T1, T2)] {
 
     override type Composed = (L, T1, T2)
 
     def compose(l: Tuple1[L], r: (T1, T2)): (L, T1, T2) =
       (l._1, r._1, r._2)
     
-    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
-      (Tuple1(c._1), (c._2, c._3))
-    
   }
-  implicit def `T3+T1`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Composition[(T1, T2, T3), Tuple1[R]] {
+  implicit def `T3+T1`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Compose[(T1, T2, T3), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, R)
 
     def compose(l: (T1, T2, T3), r: Tuple1[R]): (T1, T2, T3, R) =
       (l._1, l._2, l._3, r._1)
     
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
-      ((c._1, c._2, c._3), Tuple1(c._4))
-    
   }
-  implicit def `T1+T3`[L, T1, T2, T3]: Composition.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Composition[Tuple1[L], (T1, T2, T3)] {
+  implicit def `T1+T3`[L, T1, T2, T3]: Compose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Compose[Tuple1[L], (T1, T2, T3)] {
 
     override type Composed = (L, T1, T2, T3)
 
     def compose(l: Tuple1[L], r: (T1, T2, T3)): (L, T1, T2, T3) =
       (l._1, r._1, r._2, r._3)
     
-    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
-      (Tuple1(c._1), (c._2, c._3, c._4))
-    
   }
-  implicit def `T4+T1`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), Tuple1[R]] {
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, R)
 
     def compose(l: (T1, T2, T3, T4), r: Tuple1[R]): (T1, T2, T3, T4, R) =
       (l._1, l._2, l._3, l._4, r._1)
     
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
-    
   }
-  implicit def `T1+T4`[L, T1, T2, T3, T4]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Composition[Tuple1[L], (T1, T2, T3, T4)] {
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Compose[Tuple1[L], (T1, T2, T3, T4)] {
 
     override type Composed = (L, T1, T2, T3, T4)
 
     def compose(l: Tuple1[L], r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
       (l._1, r._1, r._2, r._3, r._4)
     
-    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
-    
   }
-  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), Tuple1[R]] {
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, R)
 
     def compose(l: (T1, T2, T3, T4, T5), r: Tuple1[R]): (T1, T2, T3, T4, T5, R) =
       (l._1, l._2, l._3, l._4, l._5, r._1)
     
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
-    
   }
-  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5)] {
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5)
 
     def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
       (l._1, r._1, r._2, r._3, r._4, r._5)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
+  }
+  implicit def `unit+A`[A]: Compose.Aux[Unit, A, A] = new Compose[Unit, A] {
+
+    override type Composed = A
+
+    def compose(l: Unit, r: A): A =
+      r
     
   }
-  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+  implicit def `A+unit`[A]: Compose.Aux[A, Unit, A] = new Compose[A, Unit] {
 
-    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+    override type Composed = A
 
-    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
+    def compose(l: A, r: Unit): A =
+      l
     
+  }
+
+}
+
+trait Decompose_Pri9 extends Decompose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
     def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), Tuple1(c._7))
     
   }
-  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (Tuple1[L], (T1, T2, T3, T4, T5, T6)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7))
     
   }
-  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), Tuple1(c._8))
     
   }
-  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
     
   }
-  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), Tuple1(c._9))
     
   }
-  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
     
   }
-  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), Tuple1(c._10))
     
   }
-  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
     
   }
-  implicit def `T10+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]] {
+  implicit def `T10+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), Tuple1(c._11))
     
   }
-  implicit def `T1+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
+  implicit def `T1+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T11+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]] {
+  implicit def `T11+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), Tuple1(c._12))
     
   }
-  implicit def `T1+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
+  implicit def `T1+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T12+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]] {
+  implicit def `T12+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), Tuple1(c._13))
     
   }
-  implicit def `T1+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
+  implicit def `T1+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T13+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]] {
+  implicit def `T13+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), Tuple1(c._14))
     
   }
-  implicit def `T1+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
+  implicit def `T1+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T14+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]] {
+  implicit def `T14+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), Tuple1(c._15))
     
   }
-  implicit def `T1+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
+  implicit def `T1+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T15+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]] {
+  implicit def `T15+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), Tuple1(c._16))
     
   }
-  implicit def `T1+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
+  implicit def `T1+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T16+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]] {
+  implicit def `T16+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), Tuple1(c._17))
     
   }
-  implicit def `T1+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
+  implicit def `T1+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T17+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]] {
+  implicit def `T17+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), Tuple1(c._18))
     
   }
-  implicit def `T1+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
+  implicit def `T1+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T18+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]] {
+  implicit def `T18+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), Tuple1(c._19))
     
   }
-  implicit def `T1+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
+  implicit def `T1+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T19+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]] {
+  implicit def `T19+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19), Tuple1(c._20))
     
   }
-  implicit def `T1+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
+  implicit def `T1+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T20+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]] {
+  implicit def `T20+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20), Tuple1(c._21))
     
   }
-  implicit def `T1+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
+  implicit def `T1+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T21+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]] {
+  implicit def `T21+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, l._21, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21), Tuple1(c._22))
     
   }
-  implicit def `T1+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
+  implicit def `T1+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20, r._21)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `unit+A`[A]: Composition.Aux[Unit, A, A] = new Composition[Unit, A] {
+}
 
-    override type Composed = A
+trait Decompose_Pri10 extends Decompose_Pri9 {
 
-    def compose(l: Unit, r: A): A =
-      r
+  implicit def `T1+T1`[L, R]: Decompose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Decompose[Tuple1[L], Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
+      (Tuple1(c._1), Tuple1(c._2))
+    
+  }
+
+  implicit def `T2+T1`[T1, T2, R]: Decompose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Decompose[(T1, T2), Tuple1[R]] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
+      ((c._1, c._2), Tuple1(c._3))
+    
+  }
+  implicit def `T1+T2`[L, T1, T2]: Decompose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Decompose[Tuple1[L], (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
+      (Tuple1(c._1), (c._2, c._3))
     
+  }
+  implicit def `T3+T1`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
+      ((c._1, c._2, c._3), Tuple1(c._4))
+    
+  }
+  implicit def `T1+T3`[L, T1, T2, T3]: Decompose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Decompose[Tuple1[L], (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
+      (Tuple1(c._1), (c._2, c._3, c._4))
+    
+  }
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
+    
+  }
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Decompose[Tuple1[L], (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
+    
+  }
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
+    
+  }
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
+    
+  }
+  implicit def `unit+A`[A]: Decompose.Aux[Unit, A, A] = new Decompose[Unit, A] {
+
+    override type Composed = A
+
     def decompose(c: A): (Unit, A) =
       ((), c)
     
   }
-  implicit def `A+unit`[A]: Composition.Aux[A, Unit, A] = new Composition[A, Unit] {
+  implicit def `A+unit`[A]: Decompose.Aux[A, Unit, A] = new Decompose[A, Unit] {
 
     override type Composed = A
 
-    def compose(l: A, r: Unit): A =
-      l
-    
     def decompose(c: A): (A, Unit) =
       (c, ())
     
@@ -755,19 +1125,43 @@ trait Composition_Pri10 extends Composition_Pri7 {
 
 }
 
-object Composition extends Composition_Pri10 {
-  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
+object Compose extends Compose_Pri10 {
+  type Aux[A, B, O] = Compose[A, B] { type Composed = O }
 
-  implicit def `unit+unit`: Composition.Aux[Unit, Unit, Unit] = new Composition[Unit, Unit] {
+  implicit def `unit+unit`: Compose.Aux[Unit, Unit, Unit] = new Compose[Unit, Unit] {
 
     override type Composed = Unit
 
     def compose(l: Unit, r: Unit): Unit =
       ()
     
+  }
+
+}
+
+object Decompose extends Decompose_Pri10 {
+  type Aux[A, B, O] = Decompose[A, B] { type Composed = O }
+
+  implicit def `unit+unit`: Decompose.Aux[Unit, Unit, Unit] = new Decompose[Unit, Unit] {
+
+    override type Composed = Unit
+
     def decompose(c: Unit): (Unit, Unit) =
       ((), ())
     
   }
 
 }
+
+object Composition {
+  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
+
+  implicit def implied[A, B, O](implicit c: Compose.Aux[A, B, O], d: Decompose.Aux[A, B, O]): Composition.Aux[A, B, O] = {
+    new Composition[A, B] {
+      override type Composed = O
+
+      def compose(l: A, r: B): O = c.compose(l, r)
+      def decompose(c: O): (A, B) = d.decompose(c)
+    }
+  }
+}
diff --git a/modules/full-light/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala b/modules/full-light/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
new file mode 100644
index 0000000..fb508dc
--- /dev/null
+++ b/modules/full-light/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
@@ -0,0 +1,1167 @@
+package app.tulz.tuplez
+
+object TupleComposition {
+
+  def compose[L, R](l: L, r: R)(implicit composition: Compose[L, R]): composition.Composed = composition.compose(l, r)
+  def decompose[L, R, C](c: C)(implicit composition: Decompose.Aux[L, R, C]): (L, R)       = composition.decompose(c)
+
+}
+
+trait Compose[-L, -R] {
+  type Composed
+  def compose(a: L, b: R): Composed
+}
+
+trait Decompose[L, R] {
+  type Composed
+  def decompose(c: Composed): (L, R)
+}
+
+abstract class Composition[L, R] extends Compose[L, R] with Decompose[L, R] {
+  type Composed
+}
+
+trait Compose_Pri0 {
+  implicit def `***`[A, B]: Compose.Aux[A, B, Tuple2[A, B]] = new Compose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
+    def compose(l: A, r: B): Tuple2[A, B] =
+      Tuple2(l, r)
+    
+  }
+}
+
+trait Decompose_Pri0 {
+  implicit def `***`[A, B]: Decompose.Aux[A, B, Tuple2[A, B]] = new Decompose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
+    def decompose(c: Tuple2[A, B]): (A, B) =
+      c
+    
+  }
+}
+
+trait Compose_Pri5 extends Compose_Pri0 {
+  implicit def `T1+R`[L, R]: Compose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Compose[Tuple1[L], R] {
+
+    override type Composed = Tuple2[L, R]
+
+    def compose(l: Tuple1[L], r: R): Tuple2[L, R] =
+      Tuple2(l._1, r)
+    
+  }
+  implicit def `L+T1`[L, R]: Compose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Compose[L, Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def compose(l: L, r: Tuple1[R]): Tuple2[L, R] =
+      Tuple2(l, r._1)
+    
+  }
+}
+
+trait Decompose_Pri5 extends Decompose_Pri0 {
+  implicit def `T1+R`[L, R]: Decompose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Decompose[Tuple1[L], R] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
+      Tuple2(Tuple1(c._1), c._2)
+    
+  }
+  implicit def `L+T1`[L, R]: Decompose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Decompose[L, Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (L, Tuple1[R]) =
+      Tuple2(c._1, Tuple1(c._2))
+    
+  }
+}
+
+trait Compose_Pri6 extends Compose_Pri5 {
+
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6), r: R): (T1, T2, T3, T4, T5, T6, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r)
+    
+  }
+  implicit def `scalar+T6`[L, T1, T2, T3, T4, T5, T6]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Compose[L, (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def compose(l: L, r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
+      (l, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: R): (T1, T2, T3, T4, T5, T6, T7, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r)
+    
+  }
+  implicit def `scalar+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
+      (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r)
+    
+  }
+  implicit def `scalar+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
+      (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r)
+    
+  }
+  implicit def `scalar+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
+      (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+}
+
+trait Compose_Pri7 extends Compose_Pri6 {
+
+  implicit def `T2+scalar`[T1, T2, R]: Compose.Aux[(T1, T2), R, (T1, T2, R)] = new Compose[(T1, T2), R] {
+
+    override type Composed = (T1, T2, R)
+
+    def compose(l: (T1, T2), r: R): (T1, T2, R) =
+      (l._1, l._2, r)
+    
+  }
+  implicit def `scalar+T2`[L, T1, T2]: Compose.Aux[L, (T1, T2), (L, T1, T2)] = new Compose[L, (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def compose(l: L, r: (T1, T2)): (L, T1, T2) =
+      (l, r._1, r._2)
+    
+  }
+  implicit def `T3+scalar`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Compose[(T1, T2, T3), R] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def compose(l: (T1, T2, T3), r: R): (T1, T2, T3, R) =
+      (l._1, l._2, l._3, r)
+    
+  }
+  implicit def `scalar+T3`[L, T1, T2, T3]: Compose.Aux[L, (T1, T2, T3), (L, T1, T2, T3)] = new Compose[L, (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def compose(l: L, r: (T1, T2, T3)): (L, T1, T2, T3) =
+      (l, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), R] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def compose(l: (T1, T2, T3, T4), r: R): (T1, T2, T3, T4, R) =
+      (l._1, l._2, l._3, l._4, r)
+    
+  }
+  implicit def `scalar+T4`[L, T1, T2, T3, T4]: Compose.Aux[L, (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Compose[L, (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def compose(l: L, r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
+      (l, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def compose(l: (T1, T2, T3, T4, T5), r: R): (T1, T2, T3, T4, T5, R) =
+      (l._1, l._2, l._3, l._4, l._5, r)
+    
+  }
+  implicit def `scalar+T5`[L, T1, T2, T3, T4, T5]: Compose.Aux[L, (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Compose[L, (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def compose(l: L, r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
+      (l, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+}
+
+trait Decompose_Pri6 extends Decompose_Pri5 {
+
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), c._7)
+    
+  }
+  implicit def `scalar+T6`[L, T1, T2, T3, T4, T5, T6]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Decompose[L, (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (L, (T1, T2, T3, T4, T5, T6)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7))
+    
+  }
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), c._8)
+    
+  }
+  implicit def `scalar+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (L, (T1, T2, T3, T4, T5, T6, T7)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
+    
+  }
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), c._9)
+    
+  }
+  implicit def `scalar+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (L, (T1, T2, T3, T4, T5, T6, T7, T8)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), c._10)
+    
+  }
+  implicit def `scalar+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
+    
+  }
+}
+
+trait Decompose_Pri7 extends Decompose_Pri6 {
+
+  implicit def `T2+scalar`[T1, T2, R]: Decompose.Aux[(T1, T2), R, (T1, T2, R)] = new Decompose[(T1, T2), R] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
+      ((c._1, c._2), c._3)
+    
+  }
+  implicit def `scalar+T2`[L, T1, T2]: Decompose.Aux[L, (T1, T2), (L, T1, T2)] = new Decompose[L, (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def decompose(c: (L, T1, T2)): (L, (T1, T2)) =
+      (c._1, (c._2, c._3))
+    
+  }
+  implicit def `T3+scalar`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), R] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
+      ((c._1, c._2, c._3), c._4)
+    
+  }
+  implicit def `scalar+T3`[L, T1, T2, T3]: Decompose.Aux[L, (T1, T2, T3), (L, T1, T2, T3)] = new Decompose[L, (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def decompose(c: (L, T1, T2, T3)): (L, (T1, T2, T3)) =
+      (c._1, (c._2, c._3, c._4))
+    
+  }
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), R] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
+      ((c._1, c._2, c._3, c._4), c._5)
+    
+  }
+  implicit def `scalar+T4`[L, T1, T2, T3, T4]: Decompose.Aux[L, (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Decompose[L, (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def decompose(c: (L, T1, T2, T3, T4)): (L, (T1, T2, T3, T4)) =
+      (c._1, (c._2, c._3, c._4, c._5))
+    
+  }
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
+      ((c._1, c._2, c._3, c._4, c._5), c._6)
+    
+  }
+  implicit def `scalar+T5`[L, T1, T2, T3, T4, T5]: Decompose.Aux[L, (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Decompose[L, (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5)): (L, (T1, T2, T3, T4, T5)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6))
+    
+  }
+}
+
+trait Compose_Pri9 extends Compose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
+    
+  }
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
+    
+  }
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
+    
+  }
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
+    
+  }
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T2+T5`[L1, L2, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5), (L1, L2, R1, R2, R3, R4, R5)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5)): (L1, L2, R1, R2, R3, R4, R5) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T2+T6`[L1, L2, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6), (L1, L2, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T2+T7`[L1, L2, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T2+T8`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T3+T4`[L1, L2, L3, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4), (L1, L2, L3, R1, R2, R3, R4)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4)): (L1, L2, L3, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T3+T5`[L1, L2, L3, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5), (L1, L2, L3, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T3+T6`[L1, L2, L3, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T3+T7`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T4+T3`[L1, L2, L3, L4, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3), (L1, L2, L3, L4, R1, R2, R3)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3)): (L1, L2, L3, L4, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+T4`[L1, L2, L3, L4, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4), (L1, L2, L3, L4, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T4+T5`[L1, L2, L3, L4, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T4+T6`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T5+T2`[L1, L2, L3, L4, L5, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2), (L1, L2, L3, L4, L5, R1, R2)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2)): (L1, L2, L3, L4, L5, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2)
+    
+  }
+  implicit def `T5+T3`[L1, L2, L3, L4, L5, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3), (L1, L2, L3, L4, L5, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3)
+    
+  }
+  implicit def `T5+T4`[L1, L2, L3, L4, L5, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T5+T5`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T6+T2`[L1, L2, L3, L4, L5, L6, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2), (L1, L2, L3, L4, L5, L6, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2)
+    
+  }
+  implicit def `T6+T3`[L1, L2, L3, L4, L5, L6, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3)
+    
+  }
+  implicit def `T6+T4`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T7+T2`[L1, L2, L3, L4, L5, L6, L7, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2)
+    
+  }
+  implicit def `T7+T3`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3)
+    
+  }
+  implicit def `T8+T2`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2)
+    
+  }
+}
+
+trait Compose_Pri10 extends Compose_Pri9 {
+
+  implicit def `T1+T1`[L, R]: Compose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Compose[Tuple1[L], Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def compose(l: Tuple1[L], r: Tuple1[R]): Tuple2[L, R] =
+      (l._1, r._1)
+    
+  }
+
+  implicit def `T2+T1`[T1, T2, R]: Compose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Compose[(T1, T2), Tuple1[R]] {
+
+    override type Composed = (T1, T2, R)
+
+    def compose(l: (T1, T2), r: Tuple1[R]): (T1, T2, R) =
+      (l._1, l._2, r._1)
+    
+  }
+  implicit def `T1+T2`[L, T1, T2]: Compose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Compose[Tuple1[L], (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def compose(l: Tuple1[L], r: (T1, T2)): (L, T1, T2) =
+      (l._1, r._1, r._2)
+    
+  }
+  implicit def `T3+T1`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Compose[(T1, T2, T3), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def compose(l: (T1, T2, T3), r: Tuple1[R]): (T1, T2, T3, R) =
+      (l._1, l._2, l._3, r._1)
+    
+  }
+  implicit def `T1+T3`[L, T1, T2, T3]: Compose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Compose[Tuple1[L], (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3)): (L, T1, T2, T3) =
+      (l._1, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def compose(l: (T1, T2, T3, T4), r: Tuple1[R]): (T1, T2, T3, T4, R) =
+      (l._1, l._2, l._3, l._4, r._1)
+    
+  }
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Compose[Tuple1[L], (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
+      (l._1, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def compose(l: (T1, T2, T3, T4, T5), r: Tuple1[R]): (T1, T2, T3, T4, T5, R) =
+      (l._1, l._2, l._3, l._4, l._5, r._1)
+    
+  }
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
+      (l._1, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T2+T2`[L1, L2, R1, R2]: Compose.Aux[(L1, L2), (R1, R2), (L1, L2, R1, R2)] = new Compose[(L1, L2), (R1, R2)] {
+
+    override type Composed = (L1, L2, R1, R2)
+
+    def compose(l: (L1, L2), r: (R1, R2)): (L1, L2, R1, R2) =
+      (l._1, l._2, r._1, r._2)
+    
+  }
+  implicit def `T2+T3`[L1, L2, R1, R2, R3]: Compose.Aux[(L1, L2), (R1, R2, R3), (L1, L2, R1, R2, R3)] = new Compose[(L1, L2), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, R1, R2, R3)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3)): (L1, L2, R1, R2, R3) =
+      (l._1, l._2, r._1, r._2, r._3)
+    
+  }
+  implicit def `T2+T4`[L1, L2, R1, R2, R3, R4]: Compose.Aux[(L1, L2), (R1, R2, R3, R4), (L1, L2, R1, R2, R3, R4)] = new Compose[(L1, L2), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4)): (L1, L2, R1, R2, R3, R4) =
+      (l._1, l._2, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T3+T2`[L1, L2, L3, R1, R2]: Compose.Aux[(L1, L2, L3), (R1, R2), (L1, L2, L3, R1, R2)] = new Compose[(L1, L2, L3), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, R1, R2)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2)): (L1, L2, L3, R1, R2) =
+      (l._1, l._2, l._3, r._1, r._2)
+    
+  }
+  implicit def `T3+T3`[L1, L2, L3, R1, R2, R3]: Compose.Aux[(L1, L2, L3), (R1, R2, R3), (L1, L2, L3, R1, R2, R3)] = new Compose[(L1, L2, L3), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3)): (L1, L2, L3, R1, R2, R3) =
+      (l._1, l._2, l._3, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+T2`[L1, L2, L3, L4, R1, R2]: Compose.Aux[(L1, L2, L3, L4), (R1, R2), (L1, L2, L3, L4, R1, R2)] = new Compose[(L1, L2, L3, L4), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2)): (L1, L2, L3, L4, R1, R2) =
+      (l._1, l._2, l._3, l._4, r._1, r._2)
+    
+  }
+  implicit def `unit+A`[A]: Compose.Aux[Unit, A, A] = new Compose[Unit, A] {
+
+    override type Composed = A
+
+    def compose(l: Unit, r: A): A =
+      r
+    
+  }
+  implicit def `A+unit`[A]: Compose.Aux[A, Unit, A] = new Compose[A, Unit] {
+
+    override type Composed = A
+
+    def compose(l: A, r: Unit): A =
+      l
+    
+  }
+
+}
+
+trait Decompose_Pri9 extends Decompose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), Tuple1(c._7))
+    
+  }
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (Tuple1[L], (T1, T2, T3, T4, T5, T6)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7))
+    
+  }
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), Tuple1(c._8))
+    
+  }
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
+    
+  }
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), Tuple1(c._9))
+    
+  }
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), Tuple1(c._10))
+    
+  }
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
+    
+  }
+  implicit def `T2+T5`[L1, L2, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5), (L1, L2, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5)
+
+    def decompose(c: (L1, L2, R1, R2, R3, R4, R5)): ((L1, L2), (R1, R2, R3, R4, R5)) =
+      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7))
+    
+  }
+  implicit def `T2+T6`[L1, L2, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6), (L1, L2, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6)
+
+    def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6)): ((L1, L2), (R1, R2, R3, R4, R5, R6)) =
+      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8))
+    
+  }
+  implicit def `T2+T7`[L1, L2, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7)
+
+    def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7)) =
+      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T2+T8`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)) =
+      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
+    
+  }
+  implicit def `T3+T4`[L1, L2, L3, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4), (L1, L2, L3, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4)
+
+    def decompose(c: (L1, L2, L3, R1, R2, R3, R4)): ((L1, L2, L3), (R1, R2, R3, R4)) =
+      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7))
+    
+  }
+  implicit def `T3+T5`[L1, L2, L3, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5), (L1, L2, L3, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5)
+
+    def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5)): ((L1, L2, L3), (R1, R2, R3, R4, R5)) =
+      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8))
+    
+  }
+  implicit def `T3+T6`[L1, L2, L3, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6)
+
+    def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6)) =
+      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T3+T7`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)
+
+    def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)) =
+      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10))
+    
+  }
+  implicit def `T4+T3`[L1, L2, L3, L4, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3), (L1, L2, L3, L4, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3)
+
+    def decompose(c: (L1, L2, L3, L4, R1, R2, R3)): ((L1, L2, L3, L4), (R1, R2, R3)) =
+      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7))
+    
+  }
+  implicit def `T4+T4`[L1, L2, L3, L4, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4), (L1, L2, L3, L4, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4)
+
+    def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4)): ((L1, L2, L3, L4), (R1, R2, R3, R4)) =
+      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8))
+    
+  }
+  implicit def `T4+T5`[L1, L2, L3, L4, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5)
+
+    def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5)) =
+      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T4+T6`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)
+
+    def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)) =
+      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10))
+    
+  }
+  implicit def `T5+T2`[L1, L2, L3, L4, L5, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2), (L1, L2, L3, L4, L5, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2)
+
+    def decompose(c: (L1, L2, L3, L4, L5, R1, R2)): ((L1, L2, L3, L4, L5), (R1, R2)) =
+      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7))
+    
+  }
+  implicit def `T5+T3`[L1, L2, L3, L4, L5, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3), (L1, L2, L3, L4, L5, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3)
+
+    def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3)): ((L1, L2, L3, L4, L5), (R1, R2, R3)) =
+      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8))
+    
+  }
+  implicit def `T5+T4`[L1, L2, L3, L4, L5, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4)
+
+    def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4)) =
+      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T5+T5`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)
+
+    def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)) =
+      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10))
+    
+  }
+  implicit def `T6+T2`[L1, L2, L3, L4, L5, L6, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2), (L1, L2, L3, L4, L5, L6, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2)
+
+    def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2)): ((L1, L2, L3, L4, L5, L6), (R1, R2)) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8))
+    
+  }
+  implicit def `T6+T3`[L1, L2, L3, L4, L5, L6, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3)
+
+    def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3)) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9))
+    
+  }
+  implicit def `T6+T4`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)
+
+    def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10))
+    
+  }
+  implicit def `T7+T2`[L1, L2, L3, L4, L5, L6, L7, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2)
+
+    def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2)) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9))
+    
+  }
+  implicit def `T7+T3`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)
+
+    def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10))
+    
+  }
+  implicit def `T8+T2`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)
+
+    def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10))
+    
+  }
+}
+
+trait Decompose_Pri10 extends Decompose_Pri9 {
+
+  implicit def `T1+T1`[L, R]: Decompose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Decompose[Tuple1[L], Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
+      (Tuple1(c._1), Tuple1(c._2))
+    
+  }
+
+  implicit def `T2+T1`[T1, T2, R]: Decompose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Decompose[(T1, T2), Tuple1[R]] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
+      ((c._1, c._2), Tuple1(c._3))
+    
+  }
+  implicit def `T1+T2`[L, T1, T2]: Decompose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Decompose[Tuple1[L], (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
+      (Tuple1(c._1), (c._2, c._3))
+    
+  }
+  implicit def `T3+T1`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
+      ((c._1, c._2, c._3), Tuple1(c._4))
+    
+  }
+  implicit def `T1+T3`[L, T1, T2, T3]: Decompose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Decompose[Tuple1[L], (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
+      (Tuple1(c._1), (c._2, c._3, c._4))
+    
+  }
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
+    
+  }
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Decompose[Tuple1[L], (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
+    
+  }
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
+    
+  }
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
+    
+  }
+  implicit def `T2+T2`[L1, L2, R1, R2]: Decompose.Aux[(L1, L2), (R1, R2), (L1, L2, R1, R2)] = new Decompose[(L1, L2), (R1, R2)] {
+
+    override type Composed = (L1, L2, R1, R2)
+
+    def decompose(c: (L1, L2, R1, R2)): ((L1, L2), (R1, R2)) =
+      ((c._1, c._2), (c._3, c._4))
+    
+  }
+  implicit def `T2+T3`[L1, L2, R1, R2, R3]: Decompose.Aux[(L1, L2), (R1, R2, R3), (L1, L2, R1, R2, R3)] = new Decompose[(L1, L2), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, R1, R2, R3)
+
+    def decompose(c: (L1, L2, R1, R2, R3)): ((L1, L2), (R1, R2, R3)) =
+      ((c._1, c._2), (c._3, c._4, c._5))
+    
+  }
+  implicit def `T2+T4`[L1, L2, R1, R2, R3, R4]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4), (L1, L2, R1, R2, R3, R4)] = new Decompose[(L1, L2), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4)
+
+    def decompose(c: (L1, L2, R1, R2, R3, R4)): ((L1, L2), (R1, R2, R3, R4)) =
+      ((c._1, c._2), (c._3, c._4, c._5, c._6))
+    
+  }
+  implicit def `T3+T2`[L1, L2, L3, R1, R2]: Decompose.Aux[(L1, L2, L3), (R1, R2), (L1, L2, L3, R1, R2)] = new Decompose[(L1, L2, L3), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, R1, R2)
+
+    def decompose(c: (L1, L2, L3, R1, R2)): ((L1, L2, L3), (R1, R2)) =
+      ((c._1, c._2, c._3), (c._4, c._5))
+    
+  }
+  implicit def `T3+T3`[L1, L2, L3, R1, R2, R3]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3), (L1, L2, L3, R1, R2, R3)] = new Decompose[(L1, L2, L3), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3)
+
+    def decompose(c: (L1, L2, L3, R1, R2, R3)): ((L1, L2, L3), (R1, R2, R3)) =
+      ((c._1, c._2, c._3), (c._4, c._5, c._6))
+    
+  }
+  implicit def `T4+T2`[L1, L2, L3, L4, R1, R2]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2), (L1, L2, L3, L4, R1, R2)] = new Decompose[(L1, L2, L3, L4), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2)
+
+    def decompose(c: (L1, L2, L3, L4, R1, R2)): ((L1, L2, L3, L4), (R1, R2)) =
+      ((c._1, c._2, c._3, c._4), (c._5, c._6))
+    
+  }
+  implicit def `unit+A`[A]: Decompose.Aux[Unit, A, A] = new Decompose[Unit, A] {
+
+    override type Composed = A
+
+    def decompose(c: A): (Unit, A) =
+      ((), c)
+    
+  }
+  implicit def `A+unit`[A]: Decompose.Aux[A, Unit, A] = new Decompose[A, Unit] {
+
+    override type Composed = A
+
+    def decompose(c: A): (A, Unit) =
+      (c, ())
+    
+  }
+
+}
+
+object Compose extends Compose_Pri10 {
+  type Aux[A, B, O] = Compose[A, B] { type Composed = O }
+
+  implicit def `unit+unit`: Compose.Aux[Unit, Unit, Unit] = new Compose[Unit, Unit] {
+
+    override type Composed = Unit
+
+    def compose(l: Unit, r: Unit): Unit =
+      ()
+    
+  }
+
+}
+
+object Decompose extends Decompose_Pri10 {
+  type Aux[A, B, O] = Decompose[A, B] { type Composed = O }
+
+  implicit def `unit+unit`: Decompose.Aux[Unit, Unit, Unit] = new Decompose[Unit, Unit] {
+
+    override type Composed = Unit
+
+    def decompose(c: Unit): (Unit, Unit) =
+      ((), ())
+    
+  }
+
+}
+
+object Composition {
+  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
+
+  implicit def implied[A, B, O](implicit c: Compose.Aux[A, B, O], d: Decompose.Aux[A, B, O]): Composition.Aux[A, B, O] = {
+    new Composition[A, B] {
+      override type Composed = O
+
+      def compose(l: A, r: B): O = c.compose(l, r)
+      def decompose(c: O): (A, B) = d.decompose(c)
+    }
+  }
+}
diff --git a/modules/full-light/src/main/scala/app/tulz/tuplez/TupleComposition.scala b/modules/full-light/src/main/scala/app/tulz/tuplez/TupleComposition.scala
deleted file mode 100644
index 2c69445..0000000
--- a/modules/full-light/src/main/scala/app/tulz/tuplez/TupleComposition.scala
+++ /dev/null
@@ -1,773 +0,0 @@
-package app.tulz.tuplez
-
-object TupleComposition {
-
-  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)
-  def decompose[L, R, C](c: C)(implicit composition: Composition.Aux[L, R, C]): (L, R)         = composition.decompose(c)
-
-}
-
-abstract class Composition[L, R] {
-  type Composed
-  def compose(a: L, b: R): Composed
-  def decompose(c: Composed): (L, R)
-}
-
-trait Composition_Pri0 {
-  implicit def `***`[A, B]: Composition.Aux[A, B, Tuple2[A, B]] = new Composition[A, B] {
-
-    override type Composed = Tuple2[A, B]
-
-    def compose(l: A, r: B): Tuple2[A, B] =
-      Tuple2(l, r)
-    
-    def decompose(c: Tuple2[A, B]): (A, B) =
-      c
-    
-  }
-}
-
-trait Composition_Pri5 extends Composition_Pri0{
-  implicit def `T1+R`[L, R]: Composition.Aux[Tuple1[L], R, Tuple2[L, R]] = new Composition[Tuple1[L], R] {
-
-    override type Composed = Tuple2[L, R]
-
-    def compose(l: Tuple1[L], r: R): Tuple2[L, R] =
-      Tuple2(l._1, r)
-    
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
-      Tuple2(Tuple1(c._1), c._2)
-    
-  }
-  implicit def `L+T1`[L, R]: Composition.Aux[L, Tuple1[R], Tuple2[L, R]] = new Composition[L, Tuple1[R]] {
-
-    override type Composed = Tuple2[L, R]
-
-    def compose(l: L, r: Tuple1[R]): Tuple2[L, R] =
-      Tuple2(l, r._1)
-    
-    def decompose(c: Tuple2[L, R]): (L, Tuple1[R]) =
-      Tuple2(c._1, Tuple1(c._2))
-    
-  }
-}
-
-trait Composition_Pri7 extends Composition_Pri5 {
-
-  implicit def `T2+scalar`[T1, T2, R]: Composition.Aux[(T1, T2), R, (T1, T2, R)] = new Composition[(T1, T2), R] {
-
-    override type Composed = (T1, T2, R)
-
-    def compose(l: (T1, T2), r: R): (T1, T2, R) =
-      (l._1, l._2, r)
-    
-    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
-      ((c._1, c._2), c._3)
-    
-  }
-  implicit def `scalar+T2`[L, T1, T2]: Composition.Aux[L, (T1, T2), (L, T1, T2)] = new Composition[L, (T1, T2)] {
-
-    override type Composed = (L, T1, T2)
-
-    def compose(l: L, r: (T1, T2)): (L, T1, T2) =
-      (l, r._1, r._2)
-    
-    def decompose(c: (L, T1, T2)): (L, (T1, T2)) =
-      (c._1, (c._2, c._3))
-    
-  }
-  implicit def `T3+scalar`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Composition[(T1, T2, T3), R] {
-
-    override type Composed = (T1, T2, T3, R)
-
-    def compose(l: (T1, T2, T3), r: R): (T1, T2, T3, R) =
-      (l._1, l._2, l._3, r)
-    
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
-      ((c._1, c._2, c._3), c._4)
-    
-  }
-  implicit def `scalar+T3`[L, T1, T2, T3]: Composition.Aux[L, (T1, T2, T3), (L, T1, T2, T3)] = new Composition[L, (T1, T2, T3)] {
-
-    override type Composed = (L, T1, T2, T3)
-
-    def compose(l: L, r: (T1, T2, T3)): (L, T1, T2, T3) =
-      (l, r._1, r._2, r._3)
-    
-    def decompose(c: (L, T1, T2, T3)): (L, (T1, T2, T3)) =
-      (c._1, (c._2, c._3, c._4))
-    
-  }
-  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), R] {
-
-    override type Composed = (T1, T2, T3, T4, R)
-
-    def compose(l: (T1, T2, T3, T4), r: R): (T1, T2, T3, T4, R) =
-      (l._1, l._2, l._3, l._4, r)
-    
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
-      ((c._1, c._2, c._3, c._4), c._5)
-    
-  }
-  implicit def `scalar+T4`[L, T1, T2, T3, T4]: Composition.Aux[L, (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Composition[L, (T1, T2, T3, T4)] {
-
-    override type Composed = (L, T1, T2, T3, T4)
-
-    def compose(l: L, r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
-      (l, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L, T1, T2, T3, T4)): (L, (T1, T2, T3, T4)) =
-      (c._1, (c._2, c._3, c._4, c._5))
-    
-  }
-  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, R)
-
-    def compose(l: (T1, T2, T3, T4, T5), r: R): (T1, T2, T3, T4, T5, R) =
-      (l._1, l._2, l._3, l._4, l._5, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
-      ((c._1, c._2, c._3, c._4, c._5), c._6)
-    
-  }
-  implicit def `scalar+T5`[L, T1, T2, T3, T4, T5]: Composition.Aux[L, (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Composition[L, (T1, T2, T3, T4, T5)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5)
-
-    def compose(l: L, r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
-      (l, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5)): (L, (T1, T2, T3, T4, T5)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6))
-    
-  }
-  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6), r: R): (T1, T2, T3, T4, T5, T6, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), c._7)
-    
-  }
-  implicit def `scalar+T6`[L, T1, T2, T3, T4, T5, T6]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Composition[L, (T1, T2, T3, T4, T5, T6)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6)
-
-    def compose(l: L, r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
-      (l, r._1, r._2, r._3, r._4, r._5, r._6)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (L, (T1, T2, T3, T4, T5, T6)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7))
-    
-  }
-  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: R): (T1, T2, T3, T4, T5, T6, T7, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), c._8)
-    
-  }
-  implicit def `scalar+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
-
-    def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
-      (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (L, (T1, T2, T3, T4, T5, T6, T7)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
-    
-  }
-  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), c._9)
-    
-  }
-  implicit def `scalar+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
-
-    def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
-      (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (L, (T1, T2, T3, T4, T5, T6, T7, T8)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
-    
-  }
-  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), c._10)
-    
-  }
-  implicit def `scalar+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
-
-    def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
-      (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
-    
-  }
-}
-
-trait Composition_Pri10 extends Composition_Pri7 {
-
-  implicit def `T1+T1`[L, R]: Composition.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Composition[Tuple1[L], Tuple1[R]] {
-
-    override type Composed = Tuple2[L, R]
-
-    def compose(l: Tuple1[L], r: Tuple1[R]): Tuple2[L, R] =
-      (l._1, r._1)
-    
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
-      (Tuple1(c._1), Tuple1(c._2))
-    
-  }
-
-  implicit def `T2+T1`[T1, T2, R]: Composition.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Composition[(T1, T2), Tuple1[R]] {
-
-    override type Composed = (T1, T2, R)
-
-    def compose(l: (T1, T2), r: Tuple1[R]): (T1, T2, R) =
-      (l._1, l._2, r._1)
-    
-    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
-      ((c._1, c._2), Tuple1(c._3))
-    
-  }
-  implicit def `T1+T2`[L, T1, T2]: Composition.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Composition[Tuple1[L], (T1, T2)] {
-
-    override type Composed = (L, T1, T2)
-
-    def compose(l: Tuple1[L], r: (T1, T2)): (L, T1, T2) =
-      (l._1, r._1, r._2)
-    
-    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
-      (Tuple1(c._1), (c._2, c._3))
-    
-  }
-  implicit def `T3+T1`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Composition[(T1, T2, T3), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, R)
-
-    def compose(l: (T1, T2, T3), r: Tuple1[R]): (T1, T2, T3, R) =
-      (l._1, l._2, l._3, r._1)
-    
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
-      ((c._1, c._2, c._3), Tuple1(c._4))
-    
-  }
-  implicit def `T1+T3`[L, T1, T2, T3]: Composition.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Composition[Tuple1[L], (T1, T2, T3)] {
-
-    override type Composed = (L, T1, T2, T3)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3)): (L, T1, T2, T3) =
-      (l._1, r._1, r._2, r._3)
-    
-    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
-      (Tuple1(c._1), (c._2, c._3, c._4))
-    
-  }
-  implicit def `T4+T1`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, R)
-
-    def compose(l: (T1, T2, T3, T4), r: Tuple1[R]): (T1, T2, T3, T4, R) =
-      (l._1, l._2, l._3, l._4, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
-    
-  }
-  implicit def `T1+T4`[L, T1, T2, T3, T4]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Composition[Tuple1[L], (T1, T2, T3, T4)] {
-
-    override type Composed = (L, T1, T2, T3, T4)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
-      (l._1, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
-    
-  }
-  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, R)
-
-    def compose(l: (T1, T2, T3, T4, T5), r: Tuple1[R]): (T1, T2, T3, T4, T5, R) =
-      (l._1, l._2, l._3, l._4, l._5, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
-    
-  }
-  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
-      (l._1, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
-    
-  }
-  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), Tuple1(c._7))
-    
-  }
-  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (Tuple1[L], (T1, T2, T3, T4, T5, T6)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7))
-    
-  }
-  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), Tuple1(c._8))
-    
-  }
-  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
-    
-  }
-  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), Tuple1(c._9))
-    
-  }
-  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
-    
-  }
-  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
-
-    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
-
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), Tuple1(c._10))
-    
-  }
-  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
-
-    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
-
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
-    
-  }
-  implicit def `T2+T2`[L1, L2, R1, R2]: Composition.Aux[(L1, L2), (R1, R2), (L1, L2, R1, R2)] = new Composition[(L1, L2), (R1, R2)] {
-
-    override type Composed = (L1, L2, R1, R2)
-
-    def compose(l: (L1, L2), r: (R1, R2)): (L1, L2, R1, R2) =
-      (l._1, l._2, r._1, r._2)
-    
-    def decompose(c: (L1, L2, R1, R2)): ((L1, L2), (R1, R2)) =
-      ((c._1, c._2), (c._3, c._4))
-    
-  }
-  implicit def `T2+T3`[L1, L2, R1, R2, R3]: Composition.Aux[(L1, L2), (R1, R2, R3), (L1, L2, R1, R2, R3)] = new Composition[(L1, L2), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, R1, R2, R3)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3)): (L1, L2, R1, R2, R3) =
-      (l._1, l._2, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, R1, R2, R3)): ((L1, L2), (R1, R2, R3)) =
-      ((c._1, c._2), (c._3, c._4, c._5))
-    
-  }
-  implicit def `T2+T4`[L1, L2, R1, R2, R3, R4]: Composition.Aux[(L1, L2), (R1, R2, R3, R4), (L1, L2, R1, R2, R3, R4)] = new Composition[(L1, L2), (R1, R2, R3, R4)] {
-
-    override type Composed = (L1, L2, R1, R2, R3, R4)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4)): (L1, L2, R1, R2, R3, R4) =
-      (l._1, l._2, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L1, L2, R1, R2, R3, R4)): ((L1, L2), (R1, R2, R3, R4)) =
-      ((c._1, c._2), (c._3, c._4, c._5, c._6))
-    
-  }
-  implicit def `T2+T5`[L1, L2, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5), (L1, L2, R1, R2, R3, R4, R5)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5)] {
-
-    override type Composed = (L1, L2, R1, R2, R3, R4, R5)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5)): (L1, L2, R1, R2, R3, R4, R5) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L1, L2, R1, R2, R3, R4, R5)): ((L1, L2), (R1, R2, R3, R4, R5)) =
-      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7))
-    
-  }
-  implicit def `T2+T6`[L1, L2, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6), (L1, L2, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6)] {
-
-    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6)
-    
-    def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6)): ((L1, L2), (R1, R2, R3, R4, R5, R6)) =
-      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8))
-    
-  }
-  implicit def `T2+T7`[L1, L2, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7)] {
-
-    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
-    def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7)) =
-      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9))
-    
-  }
-  implicit def `T2+T8`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)] {
-
-    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
-    def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)) =
-      ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
-    
-  }
-  implicit def `T3+T2`[L1, L2, L3, R1, R2]: Composition.Aux[(L1, L2, L3), (R1, R2), (L1, L2, L3, R1, R2)] = new Composition[(L1, L2, L3), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, R1, R2)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2)): (L1, L2, L3, R1, R2) =
-      (l._1, l._2, l._3, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, R1, R2)): ((L1, L2, L3), (R1, R2)) =
-      ((c._1, c._2, c._3), (c._4, c._5))
-    
-  }
-  implicit def `T3+T3`[L1, L2, L3, R1, R2, R3]: Composition.Aux[(L1, L2, L3), (R1, R2, R3), (L1, L2, L3, R1, R2, R3)] = new Composition[(L1, L2, L3), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, L3, R1, R2, R3)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3)): (L1, L2, L3, R1, R2, R3) =
-      (l._1, l._2, l._3, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, L3, R1, R2, R3)): ((L1, L2, L3), (R1, R2, R3)) =
-      ((c._1, c._2, c._3), (c._4, c._5, c._6))
-    
-  }
-  implicit def `T3+T4`[L1, L2, L3, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4), (L1, L2, L3, R1, R2, R3, R4)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4)] {
-
-    override type Composed = (L1, L2, L3, R1, R2, R3, R4)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4)): (L1, L2, L3, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L1, L2, L3, R1, R2, R3, R4)): ((L1, L2, L3), (R1, R2, R3, R4)) =
-      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7))
-    
-  }
-  implicit def `T3+T5`[L1, L2, L3, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5), (L1, L2, L3, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5)] {
-
-    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5)): ((L1, L2, L3), (R1, R2, R3, R4, R5)) =
-      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8))
-    
-  }
-  implicit def `T3+T6`[L1, L2, L3, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6)] {
-
-    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6)
-    
-    def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6)) =
-      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9))
-    
-  }
-  implicit def `T3+T7`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)] {
-
-    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
-    def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)) =
-      ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10))
-    
-  }
-  implicit def `T4+T2`[L1, L2, L3, L4, R1, R2]: Composition.Aux[(L1, L2, L3, L4), (R1, R2), (L1, L2, L3, L4, R1, R2)] = new Composition[(L1, L2, L3, L4), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, L4, R1, R2)
-
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2)): (L1, L2, L3, L4, R1, R2) =
-      (l._1, l._2, l._3, l._4, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, L4, R1, R2)): ((L1, L2, L3, L4), (R1, R2)) =
-      ((c._1, c._2, c._3, c._4), (c._5, c._6))
-    
-  }
-  implicit def `T4+T3`[L1, L2, L3, L4, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3), (L1, L2, L3, L4, R1, R2, R3)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, L3, L4, R1, R2, R3)
-
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3)): (L1, L2, L3, L4, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, L3, L4, R1, R2, R3)): ((L1, L2, L3, L4), (R1, R2, R3)) =
-      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7))
-    
-  }
-  implicit def `T4+T4`[L1, L2, L3, L4, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4), (L1, L2, L3, L4, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4)] {
-
-    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4)
-
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4)): ((L1, L2, L3, L4), (R1, R2, R3, R4)) =
-      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8))
-    
-  }
-  implicit def `T4+T5`[L1, L2, L3, L4, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5)] {
-
-    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5)
-
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5)) =
-      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9))
-    
-  }
-  implicit def `T4+T6`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)] {
-
-    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)
-
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6)
-    
-    def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)) =
-      ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10))
-    
-  }
-  implicit def `T5+T2`[L1, L2, L3, L4, L5, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2), (L1, L2, L3, L4, L5, R1, R2)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, R1, R2)
-
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2)): (L1, L2, L3, L4, L5, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, R1, R2)): ((L1, L2, L3, L4, L5), (R1, R2)) =
-      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7))
-    
-  }
-  implicit def `T5+T3`[L1, L2, L3, L4, L5, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3), (L1, L2, L3, L4, L5, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3)
-
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3)): ((L1, L2, L3, L4, L5), (R1, R2, R3)) =
-      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8))
-    
-  }
-  implicit def `T5+T4`[L1, L2, L3, L4, L5, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4)
-
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4)) =
-      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9))
-    
-  }
-  implicit def `T5+T5`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)
-
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)) =
-      ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10))
-    
-  }
-  implicit def `T6+T2`[L1, L2, L3, L4, L5, L6, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2), (L1, L2, L3, L4, L5, L6, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2)
-
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2)): ((L1, L2, L3, L4, L5, L6), (R1, R2)) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8))
-    
-  }
-  implicit def `T6+T3`[L1, L2, L3, L4, L5, L6, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3)
-
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3)) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9))
-    
-  }
-  implicit def `T6+T4`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)
-
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10))
-    
-  }
-  implicit def `T7+T2`[L1, L2, L3, L4, L5, L6, L7, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2)
-
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2)) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9))
-    
-  }
-  implicit def `T7+T3`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)
-
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10))
-    
-  }
-  implicit def `T8+T2`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)
-
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10))
-    
-  }
-  implicit def `unit+A`[A]: Composition.Aux[Unit, A, A] = new Composition[Unit, A] {
-
-    override type Composed = A
-
-    def compose(l: Unit, r: A): A =
-      r
-    
-    def decompose(c: A): (Unit, A) =
-      ((), c)
-    
-  }
-  implicit def `A+unit`[A]: Composition.Aux[A, Unit, A] = new Composition[A, Unit] {
-
-    override type Composed = A
-
-    def compose(l: A, r: Unit): A =
-      l
-    
-    def decompose(c: A): (A, Unit) =
-      (c, ())
-    
-  }
-
-}
-
-object Composition extends Composition_Pri10 {
-  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
-
-  implicit def `unit+unit`: Composition.Aux[Unit, Unit, Unit] = new Composition[Unit, Unit] {
-
-    override type Composed = Unit
-
-    def compose(l: Unit, r: Unit): Unit =
-      ()
-    
-    def decompose(c: Unit): (Unit, Unit) =
-      ((), ())
-    
-  }
-
-}
diff --git a/modules/full/src/main/scala/app/tulz/tuplez/TupleComposition.scala b/modules/full/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
similarity index 52%
rename from modules/full/src/main/scala/app/tulz/tuplez/TupleComposition.scala
rename to modules/full/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
index a02d042..86399be 100644
--- a/modules/full/src/main/scala/app/tulz/tuplez/TupleComposition.scala
+++ b/modules/full/src/main/scala-2/app/tulz/tuplez/TupleComposition.scala
@@ -2,3062 +2,4482 @@ package app.tulz.tuplez
 
 object TupleComposition {
 
-  def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)
-  def decompose[L, R, C](c: C)(implicit composition: Composition.Aux[L, R, C]): (L, R)         = composition.decompose(c)
+  def compose[L, R](l: L, r: R)(implicit composition: Compose[L, R]): composition.Composed = composition.compose(l, r)
+  def decompose[L, R, C](c: C)(implicit composition: Decompose.Aux[L, R, C]): (L, R)       = composition.decompose(c)
 
 }
 
-abstract class Composition[L, R] {
+trait Compose[-L, -R] {
   type Composed
   def compose(a: L, b: R): Composed
+}
+
+trait Decompose[L, R] {
+  type Composed
   def decompose(c: Composed): (L, R)
 }
 
-trait Composition_Pri0 {
-  implicit def `***`[A, B]: Composition.Aux[A, B, Tuple2[A, B]] = new Composition[A, B] {
+abstract class Composition[L, R] extends Compose[L, R] with Decompose[L, R] {
+  type Composed
+}
+
+trait Compose_Pri0 {
+  implicit def `***`[A, B]: Compose.Aux[A, B, Tuple2[A, B]] = new Compose[A, B] {
 
     override type Composed = Tuple2[A, B]
 
     def compose(l: A, r: B): Tuple2[A, B] =
       Tuple2(l, r)
     
+  }
+}
+
+trait Decompose_Pri0 {
+  implicit def `***`[A, B]: Decompose.Aux[A, B, Tuple2[A, B]] = new Decompose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
     def decompose(c: Tuple2[A, B]): (A, B) =
       c
     
   }
 }
 
-trait Composition_Pri5 extends Composition_Pri0{
-  implicit def `T1+R`[L, R]: Composition.Aux[Tuple1[L], R, Tuple2[L, R]] = new Composition[Tuple1[L], R] {
+trait Compose_Pri5 extends Compose_Pri0 {
+  implicit def `T1+R`[L, R]: Compose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Compose[Tuple1[L], R] {
 
     override type Composed = Tuple2[L, R]
 
     def compose(l: Tuple1[L], r: R): Tuple2[L, R] =
       Tuple2(l._1, r)
     
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
-      Tuple2(Tuple1(c._1), c._2)
-    
   }
-  implicit def `L+T1`[L, R]: Composition.Aux[L, Tuple1[R], Tuple2[L, R]] = new Composition[L, Tuple1[R]] {
+  implicit def `L+T1`[L, R]: Compose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Compose[L, Tuple1[R]] {
 
     override type Composed = Tuple2[L, R]
 
     def compose(l: L, r: Tuple1[R]): Tuple2[L, R] =
       Tuple2(l, r._1)
     
-    def decompose(c: Tuple2[L, R]): (L, Tuple1[R]) =
-      Tuple2(c._1, Tuple1(c._2))
-    
   }
 }
 
-trait Composition_Pri7 extends Composition_Pri5 {
-
-  implicit def `T2+scalar`[T1, T2, R]: Composition.Aux[(T1, T2), R, (T1, T2, R)] = new Composition[(T1, T2), R] {
-
-    override type Composed = (T1, T2, R)
-
-    def compose(l: (T1, T2), r: R): (T1, T2, R) =
-      (l._1, l._2, r)
-    
-    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
-      ((c._1, c._2), c._3)
-    
-  }
-  implicit def `scalar+T2`[L, T1, T2]: Composition.Aux[L, (T1, T2), (L, T1, T2)] = new Composition[L, (T1, T2)] {
-
-    override type Composed = (L, T1, T2)
-
-    def compose(l: L, r: (T1, T2)): (L, T1, T2) =
-      (l, r._1, r._2)
-    
-    def decompose(c: (L, T1, T2)): (L, (T1, T2)) =
-      (c._1, (c._2, c._3))
-    
-  }
-  implicit def `T3+scalar`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Composition[(T1, T2, T3), R] {
-
-    override type Composed = (T1, T2, T3, R)
-
-    def compose(l: (T1, T2, T3), r: R): (T1, T2, T3, R) =
-      (l._1, l._2, l._3, r)
-    
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
-      ((c._1, c._2, c._3), c._4)
-    
-  }
-  implicit def `scalar+T3`[L, T1, T2, T3]: Composition.Aux[L, (T1, T2, T3), (L, T1, T2, T3)] = new Composition[L, (T1, T2, T3)] {
-
-    override type Composed = (L, T1, T2, T3)
-
-    def compose(l: L, r: (T1, T2, T3)): (L, T1, T2, T3) =
-      (l, r._1, r._2, r._3)
-    
-    def decompose(c: (L, T1, T2, T3)): (L, (T1, T2, T3)) =
-      (c._1, (c._2, c._3, c._4))
-    
-  }
-  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), R] {
-
-    override type Composed = (T1, T2, T3, T4, R)
-
-    def compose(l: (T1, T2, T3, T4), r: R): (T1, T2, T3, T4, R) =
-      (l._1, l._2, l._3, l._4, r)
-    
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
-      ((c._1, c._2, c._3, c._4), c._5)
-    
-  }
-  implicit def `scalar+T4`[L, T1, T2, T3, T4]: Composition.Aux[L, (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Composition[L, (T1, T2, T3, T4)] {
+trait Decompose_Pri5 extends Decompose_Pri0 {
+  implicit def `T1+R`[L, R]: Decompose.Aux[Tuple1[L], R, Tuple2[L, R]] = new Decompose[Tuple1[L], R] {
 
-    override type Composed = (L, T1, T2, T3, T4)
+    override type Composed = Tuple2[L, R]
 
-    def compose(l: L, r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
-      (l, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L, T1, T2, T3, T4)): (L, (T1, T2, T3, T4)) =
-      (c._1, (c._2, c._3, c._4, c._5))
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], R) =
+      Tuple2(Tuple1(c._1), c._2)
     
   }
-  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), R] {
+  implicit def `L+T1`[L, R]: Decompose.Aux[L, Tuple1[R], Tuple2[L, R]] = new Decompose[L, Tuple1[R]] {
 
-    override type Composed = (T1, T2, T3, T4, T5, R)
+    override type Composed = Tuple2[L, R]
 
-    def compose(l: (T1, T2, T3, T4, T5), r: R): (T1, T2, T3, T4, T5, R) =
-      (l._1, l._2, l._3, l._4, l._5, r)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
-      ((c._1, c._2, c._3, c._4, c._5), c._6)
+    def decompose(c: Tuple2[L, R]): (L, Tuple1[R]) =
+      Tuple2(c._1, Tuple1(c._2))
     
   }
-  implicit def `scalar+T5`[L, T1, T2, T3, T4, T5]: Composition.Aux[L, (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Composition[L, (T1, T2, T3, T4, T5)] {
+}
 
-    override type Composed = (L, T1, T2, T3, T4, T5)
+trait Compose_Pri6 extends Compose_Pri5 {
 
-    def compose(l: L, r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
-      (l, r._1, r._2, r._3, r._4, r._5)
-    
-    def decompose(c: (L, T1, T2, T3, T4, T5)): (L, (T1, T2, T3, T4, T5)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6))
-    
-  }
-  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), R] {
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6), r: R): (T1, T2, T3, T4, T5, T6, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6), c._7)
-    
   }
-  implicit def `scalar+T6`[L, T1, T2, T3, T4, T5, T6]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Composition[L, (T1, T2, T3, T4, T5, T6)] {
+  implicit def `scalar+T6`[L, T1, T2, T3, T4, T5, T6]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Compose[L, (T1, T2, T3, T4, T5, T6)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (L, (T1, T2, T3, T4, T5, T6)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7))
-    
   }
-  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), R] {
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: R): (T1, T2, T3, T4, T5, T6, T7, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), c._8)
-    
   }
-  implicit def `scalar+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7)] {
+  implicit def `scalar+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (L, (T1, T2, T3, T4, T5, T6, T7)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
-    
   }
-  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), c._9)
-    
   }
-  implicit def `scalar+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8)] {
+  implicit def `scalar+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (L, (T1, T2, T3, T4, T5, T6, T7, T8)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
-    
   }
-  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), c._10)
-    
   }
-  implicit def `scalar+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+  implicit def `scalar+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
-    
   }
-  implicit def `T10+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R] {
+  implicit def `T10+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), c._11)
-    
   }
-  implicit def `scalar+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
+  implicit def `scalar+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11))
-    
   }
-  implicit def `T11+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R] {
+  implicit def `T11+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), c._12)
-    
   }
-  implicit def `scalar+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
+  implicit def `scalar+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12))
-    
   }
-  implicit def `T12+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R] {
+  implicit def `T12+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), c._13)
-    
   }
-  implicit def `scalar+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
+  implicit def `scalar+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
-    
   }
-  implicit def `T13+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R] {
+  implicit def `T13+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), c._14)
-    
   }
-  implicit def `scalar+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
+  implicit def `scalar+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
-    
   }
-  implicit def `T14+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R] {
+  implicit def `T14+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), c._15)
-    
   }
-  implicit def `scalar+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
+  implicit def `scalar+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
-    
   }
-  implicit def `T15+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R] {
+  implicit def `T15+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), c._16)
-    
   }
-  implicit def `scalar+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
+  implicit def `scalar+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
-    
   }
-  implicit def `T16+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R] {
+  implicit def `T16+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), c._17)
-    
   }
-  implicit def `scalar+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
+  implicit def `scalar+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
-    
   }
-  implicit def `T17+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R] {
+  implicit def `T17+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), c._18)
-    
   }
-  implicit def `scalar+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
+  implicit def `scalar+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
-    
   }
-  implicit def `T18+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R] {
+  implicit def `T18+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), c._19)
-    
   }
-  implicit def `scalar+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
+  implicit def `scalar+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
-    
   }
-  implicit def `T19+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R] {
+  implicit def `T19+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19), c._20)
-    
   }
-  implicit def `scalar+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
+  implicit def `scalar+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
-    
   }
-  implicit def `T20+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R] {
+  implicit def `T20+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20), c._21)
-    
   }
-  implicit def `scalar+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
+  implicit def `scalar+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
-    
   }
-  implicit def `T21+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R] {
+  implicit def `T21+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
 
     def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), r: R): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R) =
       (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, l._21, r)
     
-    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R) =
-      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21), c._22)
-    
   }
-  implicit def `scalar+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Composition.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Composition[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
+  implicit def `scalar+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Compose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Compose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)
 
     def compose(l: L, r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) =
       (l, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20, r._21)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) =
-      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
-    
   }
 }
 
-trait Composition_Pri10 extends Composition_Pri7 {
+trait Compose_Pri7 extends Compose_Pri6 {
 
-  implicit def `T1+T1`[L, R]: Composition.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Composition[Tuple1[L], Tuple1[R]] {
-
-    override type Composed = Tuple2[L, R]
-
-    def compose(l: Tuple1[L], r: Tuple1[R]): Tuple2[L, R] =
-      (l._1, r._1)
-    
-    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
-      (Tuple1(c._1), Tuple1(c._2))
-    
-  }
-
-  implicit def `T2+T1`[T1, T2, R]: Composition.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Composition[(T1, T2), Tuple1[R]] {
+  implicit def `T2+scalar`[T1, T2, R]: Compose.Aux[(T1, T2), R, (T1, T2, R)] = new Compose[(T1, T2), R] {
 
     override type Composed = (T1, T2, R)
 
-    def compose(l: (T1, T2), r: Tuple1[R]): (T1, T2, R) =
-      (l._1, l._2, r._1)
-    
-    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
-      ((c._1, c._2), Tuple1(c._3))
+    def compose(l: (T1, T2), r: R): (T1, T2, R) =
+      (l._1, l._2, r)
     
   }
-  implicit def `T1+T2`[L, T1, T2]: Composition.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Composition[Tuple1[L], (T1, T2)] {
+  implicit def `scalar+T2`[L, T1, T2]: Compose.Aux[L, (T1, T2), (L, T1, T2)] = new Compose[L, (T1, T2)] {
 
     override type Composed = (L, T1, T2)
 
-    def compose(l: Tuple1[L], r: (T1, T2)): (L, T1, T2) =
-      (l._1, r._1, r._2)
-    
-    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
-      (Tuple1(c._1), (c._2, c._3))
+    def compose(l: L, r: (T1, T2)): (L, T1, T2) =
+      (l, r._1, r._2)
     
   }
-  implicit def `T3+T1`[T1, T2, T3, R]: Composition.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Composition[(T1, T2, T3), Tuple1[R]] {
+  implicit def `T3+scalar`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Compose[(T1, T2, T3), R] {
 
     override type Composed = (T1, T2, T3, R)
 
-    def compose(l: (T1, T2, T3), r: Tuple1[R]): (T1, T2, T3, R) =
-      (l._1, l._2, l._3, r._1)
-    
-    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
-      ((c._1, c._2, c._3), Tuple1(c._4))
+    def compose(l: (T1, T2, T3), r: R): (T1, T2, T3, R) =
+      (l._1, l._2, l._3, r)
     
   }
-  implicit def `T1+T3`[L, T1, T2, T3]: Composition.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Composition[Tuple1[L], (T1, T2, T3)] {
+  implicit def `scalar+T3`[L, T1, T2, T3]: Compose.Aux[L, (T1, T2, T3), (L, T1, T2, T3)] = new Compose[L, (T1, T2, T3)] {
 
     override type Composed = (L, T1, T2, T3)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3)): (L, T1, T2, T3) =
-      (l._1, r._1, r._2, r._3)
-    
-    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
-      (Tuple1(c._1), (c._2, c._3, c._4))
+    def compose(l: L, r: (T1, T2, T3)): (L, T1, T2, T3) =
+      (l, r._1, r._2, r._3)
     
   }
-  implicit def `T4+T1`[T1, T2, T3, T4, R]: Composition.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Composition[(T1, T2, T3, T4), Tuple1[R]] {
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), R] {
 
     override type Composed = (T1, T2, T3, T4, R)
 
-    def compose(l: (T1, T2, T3, T4), r: Tuple1[R]): (T1, T2, T3, T4, R) =
-      (l._1, l._2, l._3, l._4, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
+    def compose(l: (T1, T2, T3, T4), r: R): (T1, T2, T3, T4, R) =
+      (l._1, l._2, l._3, l._4, r)
     
   }
-  implicit def `T1+T4`[L, T1, T2, T3, T4]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Composition[Tuple1[L], (T1, T2, T3, T4)] {
+  implicit def `scalar+T4`[L, T1, T2, T3, T4]: Compose.Aux[L, (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Compose[L, (T1, T2, T3, T4)] {
 
     override type Composed = (L, T1, T2, T3, T4)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
-      (l._1, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
+    def compose(l: L, r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
+      (l, r._1, r._2, r._3, r._4)
     
   }
-  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Composition.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Composition[(T1, T2, T3, T4, T5), Tuple1[R]] {
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), R] {
 
     override type Composed = (T1, T2, T3, T4, T5, R)
 
-    def compose(l: (T1, T2, T3, T4, T5), r: Tuple1[R]): (T1, T2, T3, T4, T5, R) =
-      (l._1, l._2, l._3, l._4, l._5, r._1)
-    
-    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
-      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
+    def compose(l: (T1, T2, T3, T4, T5), r: R): (T1, T2, T3, T4, T5, R) =
+      (l._1, l._2, l._3, l._4, l._5, r)
     
   }
-  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5)] {
+  implicit def `scalar+T5`[L, T1, T2, T3, T4, T5]: Compose.Aux[L, (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Compose[L, (T1, T2, T3, T4, T5)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
-      (l._1, r._1, r._2, r._3, r._4, r._5)
+    def compose(l: L, r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
+      (l, r._1, r._2, r._3, r._4, r._5)
     
-    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
-      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
+  }
+}
+
+trait Decompose_Pri6 extends Decompose_Pri5 {
+
+  implicit def `T6+scalar`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), R, (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6), c._7)
+    
+  }
+  implicit def `scalar+T6`[L, T1, T2, T3, T4, T5, T6]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Decompose[L, (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (L, (T1, T2, T3, T4, T5, T6)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7))
+    
+  }
+  implicit def `T7+scalar`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), R, (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), c._8)
+    
+  }
+  implicit def `scalar+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (L, (T1, T2, T3, T4, T5, T6, T7)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
+    
+  }
+  implicit def `T8+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), R, (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), c._9)
+    
+  }
+  implicit def `scalar+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (L, (T1, T2, T3, T4, T5, T6, T7, T8)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
+    
+  }
+  implicit def `T9+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), c._10)
+    
+  }
+  implicit def `scalar+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
+    
+  }
+  implicit def `T10+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), c._11)
+    
+  }
+  implicit def `scalar+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11))
+    
+  }
+  implicit def `T11+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), c._12)
+    
+  }
+  implicit def `scalar+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12))
+    
+  }
+  implicit def `T12+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), c._13)
+    
+  }
+  implicit def `scalar+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
+    
+  }
+  implicit def `T13+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), c._14)
+    
+  }
+  implicit def `scalar+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
+    
+  }
+  implicit def `T14+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), c._15)
+    
+  }
+  implicit def `scalar+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
+    
+  }
+  implicit def `T15+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), c._16)
+    
+  }
+  implicit def `scalar+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
+    
+  }
+  implicit def `T16+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), c._17)
+    
+  }
+  implicit def `scalar+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
+    
+  }
+  implicit def `T17+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), c._18)
+    
+  }
+  implicit def `scalar+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
+    
+  }
+  implicit def `T18+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), c._19)
+    
+  }
+  implicit def `scalar+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
+    
+  }
+  implicit def `T19+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19), c._20)
+    
+  }
+  implicit def `scalar+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
+    
+  }
+  implicit def `T20+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20), c._21)
+    
+  }
+  implicit def `scalar+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
+    
+  }
+  implicit def `T21+scalar`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), R) =
+      ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21), c._22)
+    
+  }
+  implicit def `scalar+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Decompose.Aux[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Decompose[L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (L, (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
+    
+  }
+}
+
+trait Decompose_Pri7 extends Decompose_Pri6 {
+
+  implicit def `T2+scalar`[T1, T2, R]: Decompose.Aux[(T1, T2), R, (T1, T2, R)] = new Decompose[(T1, T2), R] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), R) =
+      ((c._1, c._2), c._3)
+    
+  }
+  implicit def `scalar+T2`[L, T1, T2]: Decompose.Aux[L, (T1, T2), (L, T1, T2)] = new Decompose[L, (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def decompose(c: (L, T1, T2)): (L, (T1, T2)) =
+      (c._1, (c._2, c._3))
+    
+  }
+  implicit def `T3+scalar`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), R, (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), R] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), R) =
+      ((c._1, c._2, c._3), c._4)
+    
+  }
+  implicit def `scalar+T3`[L, T1, T2, T3]: Decompose.Aux[L, (T1, T2, T3), (L, T1, T2, T3)] = new Decompose[L, (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def decompose(c: (L, T1, T2, T3)): (L, (T1, T2, T3)) =
+      (c._1, (c._2, c._3, c._4))
+    
+  }
+  implicit def `T4+scalar`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), R, (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), R] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), R) =
+      ((c._1, c._2, c._3, c._4), c._5)
+    
+  }
+  implicit def `scalar+T4`[L, T1, T2, T3, T4]: Decompose.Aux[L, (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Decompose[L, (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def decompose(c: (L, T1, T2, T3, T4)): (L, (T1, T2, T3, T4)) =
+      (c._1, (c._2, c._3, c._4, c._5))
+    
+  }
+  implicit def `T5+scalar`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), R, (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), R] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), R) =
+      ((c._1, c._2, c._3, c._4, c._5), c._6)
+    
+  }
+  implicit def `scalar+T5`[L, T1, T2, T3, T4, T5]: Decompose.Aux[L, (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Decompose[L, (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5)): (L, (T1, T2, T3, T4, T5)) =
+      (c._1, (c._2, c._3, c._4, c._5, c._6))
+    
+  }
+}
+
+trait Compose_Pri9 extends Compose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Compose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
+    
+  }
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
+    
+  }
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
+    
+  }
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
+    
+  }
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T10+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1)
+    
+  }
+  implicit def `T1+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T11+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1)
+    
+  }
+  implicit def `T1+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T12+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1)
+    
+  }
+  implicit def `T1+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T13+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1)
+    
+  }
+  implicit def `T1+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T14+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1)
+    
+  }
+  implicit def `T1+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T15+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1)
+    
+  }
+  implicit def `T1+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T16+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1)
+    
+  }
+  implicit def `T1+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
+    
+  }
+  implicit def `T17+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1)
+    
+  }
+  implicit def `T1+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
+    
+  }
+  implicit def `T18+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1)
+    
+  }
+  implicit def `T1+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
+    
+  }
+  implicit def `T19+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1)
+    
+  }
+  implicit def `T1+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
+    
+  }
+  implicit def `T20+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r._1)
+    
+  }
+  implicit def `T1+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20)
+    
+  }
+  implicit def `T21+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Compose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Compose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
+
+    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, l._21, r._1)
+    
+  }
+  implicit def `T1+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) =
+      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20, r._21)
+    
+  }
+  implicit def `T2+T5`[L1, L2, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5), (L1, L2, R1, R2, R3, R4, R5)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5)): (L1, L2, R1, R2, R3, R4, R5) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T2+T6`[L1, L2, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6), (L1, L2, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T2+T7`[L1, L2, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T2+T8`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T2+T9`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T2+T10`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T2+T11`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T2+T12`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T2+T13`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T2+T14`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T2+T15`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T2+T16`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
+    
+  }
+  implicit def `T2+T17`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
+    
+  }
+  implicit def `T2+T18`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
+    
+  }
+  implicit def `T2+T19`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
+    
+  }
+  implicit def `T2+T20`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20]: Compose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)] = new Compose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20) =
+      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20)
+    
+  }
+  implicit def `T3+T4`[L1, L2, L3, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4), (L1, L2, L3, R1, R2, R3, R4)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4)): (L1, L2, L3, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T3+T5`[L1, L2, L3, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5), (L1, L2, L3, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T3+T6`[L1, L2, L3, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T3+T7`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T3+T8`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T3+T9`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T3+T10`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T3+T11`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T3+T12`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T3+T13`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T3+T14`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T3+T15`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T3+T16`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
+    
+  }
+  implicit def `T3+T17`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
+    
+  }
+  implicit def `T3+T18`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
+    
+  }
+  implicit def `T3+T19`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19]: Compose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] = new Compose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19) =
+      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
+    
+  }
+  implicit def `T4+T3`[L1, L2, L3, L4, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3), (L1, L2, L3, L4, R1, R2, R3)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3)): (L1, L2, L3, L4, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+T4`[L1, L2, L3, L4, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4), (L1, L2, L3, L4, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T4+T5`[L1, L2, L3, L4, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T4+T6`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T4+T7`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T4+T8`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T4+T9`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T4+T10`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T4+T11`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T4+T12`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T4+T13`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T4+T14`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T4+T15`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T4+T16`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
+    
+  }
+  implicit def `T4+T17`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
+    
+  }
+  implicit def `T4+T18`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Compose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Compose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18) =
+      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
+    
+  }
+  implicit def `T5+T2`[L1, L2, L3, L4, L5, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2), (L1, L2, L3, L4, L5, R1, R2)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2)): (L1, L2, L3, L4, L5, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2)
+    
+  }
+  implicit def `T5+T3`[L1, L2, L3, L4, L5, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3), (L1, L2, L3, L4, L5, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3)
+    
+  }
+  implicit def `T5+T4`[L1, L2, L3, L4, L5, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T5+T5`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T5+T6`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T5+T7`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T5+T8`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T5+T9`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T5+T10`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T5+T11`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T5+T12`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T5+T13`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T5+T14`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T5+T15`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T5+T16`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
+    
+  }
+  implicit def `T5+T17`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Compose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Compose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
+
+    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
+      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
+    
+  }
+  implicit def `T6+T2`[L1, L2, L3, L4, L5, L6, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2), (L1, L2, L3, L4, L5, L6, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2)
+    
+  }
+  implicit def `T6+T3`[L1, L2, L3, L4, L5, L6, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3)
+    
+  }
+  implicit def `T6+T4`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T6+T5`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T6+T6`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T6+T7`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T6+T8`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T6+T9`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T6+T10`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T6+T11`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T6+T12`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T6+T13`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T6+T14`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T6+T15`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T6+T16`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Compose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Compose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
+    
+  }
+  implicit def `T7+T2`[L1, L2, L3, L4, L5, L6, L7, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2)
+    
+  }
+  implicit def `T7+T3`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3)
+    
+  }
+  implicit def `T7+T4`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T7+T5`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T7+T6`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T7+T7`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T7+T8`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T7+T9`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T7+T10`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T7+T11`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T7+T12`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T7+T13`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T7+T14`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T7+T15`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Compose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
+    
+  }
+  implicit def `T8+T2`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2)
+    
+  }
+  implicit def `T8+T3`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3)
+    
+  }
+  implicit def `T8+T4`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T8+T5`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T8+T6`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T8+T7`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T8+T8`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T8+T9`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T8+T10`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T8+T11`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T8+T12`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T8+T13`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T8+T14`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
+    
+  }
+  implicit def `T9+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2)
+    
+  }
+  implicit def `T9+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3)
+    
+  }
+  implicit def `T9+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T9+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T9+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T9+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T9+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T9+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T9+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T9+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T9+T12`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T9+T13`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
+    
+  }
+  implicit def `T10+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2)
+    
+  }
+  implicit def `T10+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3)
+    
+  }
+  implicit def `T10+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T10+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T10+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T10+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T10+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T10+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T10+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T10+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T10+T12`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
+    
+  }
+  implicit def `T11+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2)
+    
+  }
+  implicit def `T11+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3)
+    
+  }
+  implicit def `T11+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T11+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T11+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T11+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T11+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T11+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T11+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T11+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
+    
+  }
+  implicit def `T12+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2)
+    
+  }
+  implicit def `T12+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3)
+    
+  }
+  implicit def `T12+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T12+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T12+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T12+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T12+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T12+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T12+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
+    
+  }
+  implicit def `T13+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2)
+    
+  }
+  implicit def `T13+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3)
+    
+  }
+  implicit def `T13+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T13+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T13+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T13+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T13+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T13+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
+    
+  }
+  implicit def `T14+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2)
+    
+  }
+  implicit def `T14+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3)
+    
+  }
+  implicit def `T14+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T14+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T14+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T14+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T14+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
+    
+  }
+  implicit def `T15+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2)
+    
+  }
+  implicit def `T15+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3)
+    
+  }
+  implicit def `T15+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T15+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T15+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T15+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6, R7)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
+    
+  }
+  implicit def `T16+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2)
+    
+  }
+  implicit def `T16+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3)
+    
+  }
+  implicit def `T16+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T16+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T16+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5, R6)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3, r._4, r._5, r._6)
+    
+  }
+  implicit def `T17+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2)
+    
+  }
+  implicit def `T17+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2, r._3)
     
   }
-  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Composition[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+  implicit def `T17+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4)] {
 
-    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1)
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T17+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4, R5)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T18+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1, r._2)
+    
+  }
+  implicit def `T18+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1, r._2, r._3)
+    
+  }
+  implicit def `T18+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T19+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1, r._2)
+    
+  }
+  implicit def `T19+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1, r._2, r._3)
+    
+  }
+  implicit def `T20+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2]: Compose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2)] = new Compose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2) =
+      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r._1, r._2)
+    
+  }
+}
+
+trait Compose_Pri10 extends Compose_Pri9 {
+
+  implicit def `T1+T1`[L, R]: Compose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Compose[Tuple1[L], Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def compose(l: Tuple1[L], r: Tuple1[R]): Tuple2[L, R] =
+      (l._1, r._1)
+    
+  }
+
+  implicit def `T2+T1`[T1, T2, R]: Compose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Compose[(T1, T2), Tuple1[R]] {
+
+    override type Composed = (T1, T2, R)
+
+    def compose(l: (T1, T2), r: Tuple1[R]): (T1, T2, R) =
+      (l._1, l._2, r._1)
+    
+  }
+  implicit def `T1+T2`[L, T1, T2]: Compose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Compose[Tuple1[L], (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def compose(l: Tuple1[L], r: (T1, T2)): (L, T1, T2) =
+      (l._1, r._1, r._2)
+    
+  }
+  implicit def `T3+T1`[T1, T2, T3, R]: Compose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Compose[(T1, T2, T3), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def compose(l: (T1, T2, T3), r: Tuple1[R]): (T1, T2, T3, R) =
+      (l._1, l._2, l._3, r._1)
+    
+  }
+  implicit def `T1+T3`[L, T1, T2, T3]: Compose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Compose[Tuple1[L], (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3)): (L, T1, T2, T3) =
+      (l._1, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Compose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Compose[(T1, T2, T3, T4), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def compose(l: (T1, T2, T3, T4), r: Tuple1[R]): (T1, T2, T3, T4, R) =
+      (l._1, l._2, l._3, l._4, r._1)
+    
+  }
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Compose[Tuple1[L], (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4)): (L, T1, T2, T3, T4) =
+      (l._1, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Compose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Compose[(T1, T2, T3, T4, T5), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def compose(l: (T1, T2, T3, T4, T5), r: Tuple1[R]): (T1, T2, T3, T4, T5, R) =
+      (l._1, l._2, l._3, l._4, l._5, r._1)
+    
+  }
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Compose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Compose[Tuple1[L], (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5)): (L, T1, T2, T3, T4, T5) =
+      (l._1, r._1, r._2, r._3, r._4, r._5)
+    
+  }
+  implicit def `T2+T2`[L1, L2, R1, R2]: Compose.Aux[(L1, L2), (R1, R2), (L1, L2, R1, R2)] = new Compose[(L1, L2), (R1, R2)] {
+
+    override type Composed = (L1, L2, R1, R2)
+
+    def compose(l: (L1, L2), r: (R1, R2)): (L1, L2, R1, R2) =
+      (l._1, l._2, r._1, r._2)
+    
+  }
+  implicit def `T2+T3`[L1, L2, R1, R2, R3]: Compose.Aux[(L1, L2), (R1, R2, R3), (L1, L2, R1, R2, R3)] = new Compose[(L1, L2), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, R1, R2, R3)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3)): (L1, L2, R1, R2, R3) =
+      (l._1, l._2, r._1, r._2, r._3)
+    
+  }
+  implicit def `T2+T4`[L1, L2, R1, R2, R3, R4]: Compose.Aux[(L1, L2), (R1, R2, R3, R4), (L1, L2, R1, R2, R3, R4)] = new Compose[(L1, L2), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4)
+
+    def compose(l: (L1, L2), r: (R1, R2, R3, R4)): (L1, L2, R1, R2, R3, R4) =
+      (l._1, l._2, r._1, r._2, r._3, r._4)
+    
+  }
+  implicit def `T3+T2`[L1, L2, L3, R1, R2]: Compose.Aux[(L1, L2, L3), (R1, R2), (L1, L2, L3, R1, R2)] = new Compose[(L1, L2, L3), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, R1, R2)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2)): (L1, L2, L3, R1, R2) =
+      (l._1, l._2, l._3, r._1, r._2)
+    
+  }
+  implicit def `T3+T3`[L1, L2, L3, R1, R2, R3]: Compose.Aux[(L1, L2, L3), (R1, R2, R3), (L1, L2, L3, R1, R2, R3)] = new Compose[(L1, L2, L3), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3)
+
+    def compose(l: (L1, L2, L3), r: (R1, R2, R3)): (L1, L2, L3, R1, R2, R3) =
+      (l._1, l._2, l._3, r._1, r._2, r._3)
+    
+  }
+  implicit def `T4+T2`[L1, L2, L3, L4, R1, R2]: Compose.Aux[(L1, L2, L3, L4), (R1, R2), (L1, L2, L3, L4, R1, R2)] = new Compose[(L1, L2, L3, L4), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2)
+
+    def compose(l: (L1, L2, L3, L4), r: (R1, R2)): (L1, L2, L3, L4, R1, R2) =
+      (l._1, l._2, l._3, l._4, r._1, r._2)
+    
+  }
+  implicit def `unit+A`[A]: Compose.Aux[Unit, A, A] = new Compose[Unit, A] {
+
+    override type Composed = A
+
+    def compose(l: Unit, r: A): A =
+      r
+    
+  }
+  implicit def `A+unit`[A]: Compose.Aux[A, Unit, A] = new Compose[A, Unit] {
+
+    override type Composed = A
+
+    def compose(l: A, r: Unit): A =
+      l
     
+  }
+
+}
+
+trait Decompose_Pri9 extends Decompose_Pri7 {
+
+  implicit def `T6+T1`[T1, T2, T3, T4, T5, T6, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6), Tuple1[R], (T1, T2, T3, T4, T5, T6, R)] = new Decompose[(T1, T2, T3, T4, T5, T6), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, T6, R)
+
     def decompose(c: (T1, T2, T3, T4, T5, T6, R)): ((T1, T2, T3, T4, T5, T6), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), Tuple1(c._7))
     
   }
-  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
+  implicit def `T1+T6`[L, T1, T2, T3, T4, T5, T6]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6), (L, T1, T2, T3, T4, T5, T6)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6)): (L, T1, T2, T3, T4, T5, T6) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6)): (Tuple1[L], (T1, T2, T3, T4, T5, T6)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7))
     
   }
-  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
+  implicit def `T7+T1`[T1, T2, T3, T4, T5, T6, T7, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, R)): ((T1, T2, T3, T4, T5, T6, T7), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), Tuple1(c._8))
     
   }
-  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
+  implicit def `T1+T7`[L, T1, T2, T3, T4, T5, T6, T7]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7), (L, T1, T2, T3, T4, T5, T6, T7)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7)): (L, T1, T2, T3, T4, T5, T6, T7) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8))
     
   }
-  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
+  implicit def `T8+T1`[T1, T2, T3, T4, T5, T6, T7, T8, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, R)): ((T1, T2, T3, T4, T5, T6, T7, T8), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), Tuple1(c._9))
     
   }
-  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
+  implicit def `T1+T8`[L, T1, T2, T3, T4, T5, T6, T7, T8]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8), (L, T1, T2, T3, T4, T5, T6, T7, T8)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8)): (L, T1, T2, T3, T4, T5, T6, T7, T8) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9))
     
   }
-  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
+  implicit def `T9+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), Tuple1(c._10))
     
   }
-  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
+  implicit def `T1+T9`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
     
   }
-  implicit def `T10+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]] {
+  implicit def `T10+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), Tuple1(c._11))
     
   }
-  implicit def `T1+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
+  implicit def `T1+T10`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T11+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]] {
+  implicit def `T11+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), Tuple1(c._12))
     
   }
-  implicit def `T1+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
+  implicit def `T1+T11`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T12+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]] {
+  implicit def `T12+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), Tuple1(c._13))
     
   }
-  implicit def `T1+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
+  implicit def `T1+T12`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T13+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]] {
+  implicit def `T13+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), Tuple1(c._14))
     
   }
-  implicit def `T1+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
+  implicit def `T1+T13`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T14+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]] {
+  implicit def `T14+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), Tuple1(c._15))
     
   }
-  implicit def `T1+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
+  implicit def `T1+T14`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T15+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]] {
+  implicit def `T15+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), Tuple1(c._16))
     
   }
-  implicit def `T1+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
+  implicit def `T1+T15`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T16+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]] {
+  implicit def `T16+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), Tuple1(c._17))
     
   }
-  implicit def `T1+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
+  implicit def `T1+T16`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T17+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]] {
+  implicit def `T17+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), Tuple1(c._18))
     
   }
-  implicit def `T1+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
+  implicit def `T1+T17`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T18+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]] {
+  implicit def `T18+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), Tuple1(c._19))
     
   }
-  implicit def `T1+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
+  implicit def `T1+T18`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T19+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]] {
+  implicit def `T19+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19), Tuple1(c._20))
     
   }
-  implicit def `T1+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
+  implicit def `T1+T19`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T20+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]] {
+  implicit def `T20+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20), Tuple1(c._21))
     
   }
-  implicit def `T1+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
+  implicit def `T1+T20`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T21+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Composition.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Composition[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]] {
+  implicit def `T21+T1`[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]: Decompose.Aux[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)] = new Decompose[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]] {
 
     override type Composed = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)
 
-    def compose(l: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), r: Tuple1[R]): (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, l._21, r._1)
-    
     def decompose(c: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R)): ((T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), Tuple1[R]) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21), Tuple1(c._22))
     
   }
-  implicit def `T1+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Composition.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Composition[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
+  implicit def `T1+T21`[L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)] {
 
     override type Composed = (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)
 
-    def compose(l: Tuple1[L], r: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) =
-      (l._1, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20, r._21)
-    
     def decompose(c: (L, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)): (Tuple1[L], (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) =
       (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T2+T2`[L1, L2, R1, R2]: Composition.Aux[(L1, L2), (R1, R2), (L1, L2, R1, R2)] = new Composition[(L1, L2), (R1, R2)] {
-
-    override type Composed = (L1, L2, R1, R2)
-
-    def compose(l: (L1, L2), r: (R1, R2)): (L1, L2, R1, R2) =
-      (l._1, l._2, r._1, r._2)
-    
-    def decompose(c: (L1, L2, R1, R2)): ((L1, L2), (R1, R2)) =
-      ((c._1, c._2), (c._3, c._4))
-    
-  }
-  implicit def `T2+T3`[L1, L2, R1, R2, R3]: Composition.Aux[(L1, L2), (R1, R2, R3), (L1, L2, R1, R2, R3)] = new Composition[(L1, L2), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, R1, R2, R3)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3)): (L1, L2, R1, R2, R3) =
-      (l._1, l._2, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, R1, R2, R3)): ((L1, L2), (R1, R2, R3)) =
-      ((c._1, c._2), (c._3, c._4, c._5))
-    
-  }
-  implicit def `T2+T4`[L1, L2, R1, R2, R3, R4]: Composition.Aux[(L1, L2), (R1, R2, R3, R4), (L1, L2, R1, R2, R3, R4)] = new Composition[(L1, L2), (R1, R2, R3, R4)] {
-
-    override type Composed = (L1, L2, R1, R2, R3, R4)
-
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4)): (L1, L2, R1, R2, R3, R4) =
-      (l._1, l._2, r._1, r._2, r._3, r._4)
-    
-    def decompose(c: (L1, L2, R1, R2, R3, R4)): ((L1, L2), (R1, R2, R3, R4)) =
-      ((c._1, c._2), (c._3, c._4, c._5, c._6))
-    
-  }
-  implicit def `T2+T5`[L1, L2, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5), (L1, L2, R1, R2, R3, R4, R5)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5)] {
+  implicit def `T2+T5`[L1, L2, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5), (L1, L2, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5)): (L1, L2, R1, R2, R3, R4, R5) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5)): ((L1, L2), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7))
     
   }
-  implicit def `T2+T6`[L1, L2, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6), (L1, L2, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T2+T6`[L1, L2, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6), (L1, L2, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6)): ((L1, L2), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8))
     
   }
-  implicit def `T2+T7`[L1, L2, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T2+T7`[L1, L2, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9))
     
   }
-  implicit def `T2+T8`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T2+T8`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10))
     
   }
-  implicit def `T2+T9`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T2+T9`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T2+T10`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T2+T10`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T2+T11`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T2+T11`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T2+T12`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T2+T12`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T2+T13`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T2+T13`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T2+T14`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+  implicit def `T2+T14`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T2+T15`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+  implicit def `T2+T15`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T2+T16`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+  implicit def `T2+T16`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T2+T17`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+  implicit def `T2+T17`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T2+T18`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
+  implicit def `T2+T18`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T2+T19`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] {
+  implicit def `T2+T19`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T2+T20`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20]: Composition.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)] = new Composition[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)] {
+  implicit def `T2+T20`[L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20), (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)] = new Decompose[(L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)] {
 
     override type Composed = (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)
 
-    def compose(l: (L1, L2), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)): (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20) =
-      (l._1, l._2, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19, r._20)
-    
     def decompose(c: (L1, L2, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)): ((L1, L2), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19, R20)) =
       ((c._1, c._2), (c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T3+T2`[L1, L2, L3, R1, R2]: Composition.Aux[(L1, L2, L3), (R1, R2), (L1, L2, L3, R1, R2)] = new Composition[(L1, L2, L3), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, R1, R2)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2)): (L1, L2, L3, R1, R2) =
-      (l._1, l._2, l._3, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, R1, R2)): ((L1, L2, L3), (R1, R2)) =
-      ((c._1, c._2, c._3), (c._4, c._5))
-    
-  }
-  implicit def `T3+T3`[L1, L2, L3, R1, R2, R3]: Composition.Aux[(L1, L2, L3), (R1, R2, R3), (L1, L2, L3, R1, R2, R3)] = new Composition[(L1, L2, L3), (R1, R2, R3)] {
-
-    override type Composed = (L1, L2, L3, R1, R2, R3)
-
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3)): (L1, L2, L3, R1, R2, R3) =
-      (l._1, l._2, l._3, r._1, r._2, r._3)
-    
-    def decompose(c: (L1, L2, L3, R1, R2, R3)): ((L1, L2, L3), (R1, R2, R3)) =
-      ((c._1, c._2, c._3), (c._4, c._5, c._6))
-    
-  }
-  implicit def `T3+T4`[L1, L2, L3, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4), (L1, L2, L3, R1, R2, R3, R4)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4)] {
+  implicit def `T3+T4`[L1, L2, L3, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4), (L1, L2, L3, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4)): (L1, L2, L3, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4)): ((L1, L2, L3), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7))
     
   }
-  implicit def `T3+T5`[L1, L2, L3, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5), (L1, L2, L3, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5)] {
+  implicit def `T3+T5`[L1, L2, L3, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5), (L1, L2, L3, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5)): ((L1, L2, L3), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8))
     
   }
-  implicit def `T3+T6`[L1, L2, L3, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T3+T6`[L1, L2, L3, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9))
     
   }
-  implicit def `T3+T7`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T3+T7`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10))
     
   }
-  implicit def `T3+T8`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T3+T8`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T3+T9`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T3+T9`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T3+T10`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T3+T10`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T3+T11`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T3+T11`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T3+T12`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T3+T12`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T3+T13`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T3+T13`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T3+T14`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+  implicit def `T3+T14`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T3+T15`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+  implicit def `T3+T15`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T3+T16`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+  implicit def `T3+T16`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T3+T17`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+  implicit def `T3+T17`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T3+T18`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
+  implicit def `T3+T18`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T3+T19`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19]: Composition.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] = new Composition[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] {
+  implicit def `T3+T19`[L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19), (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] = new Decompose[(L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)] {
 
     override type Composed = (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)
 
-    def compose(l: (L1, L2, L3), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)): (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19) =
-      (l._1, l._2, l._3, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18, r._19)
-    
     def decompose(c: (L1, L2, L3, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)): ((L1, L2, L3), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18, R19)) =
       ((c._1, c._2, c._3), (c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T4+T2`[L1, L2, L3, L4, R1, R2]: Composition.Aux[(L1, L2, L3, L4), (R1, R2), (L1, L2, L3, L4, R1, R2)] = new Composition[(L1, L2, L3, L4), (R1, R2)] {
-
-    override type Composed = (L1, L2, L3, L4, R1, R2)
-
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2)): (L1, L2, L3, L4, R1, R2) =
-      (l._1, l._2, l._3, l._4, r._1, r._2)
-    
-    def decompose(c: (L1, L2, L3, L4, R1, R2)): ((L1, L2, L3, L4), (R1, R2)) =
-      ((c._1, c._2, c._3, c._4), (c._5, c._6))
-    
-  }
-  implicit def `T4+T3`[L1, L2, L3, L4, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3), (L1, L2, L3, L4, R1, R2, R3)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3)] {
+  implicit def `T4+T3`[L1, L2, L3, L4, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3), (L1, L2, L3, L4, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3)): (L1, L2, L3, L4, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3)): ((L1, L2, L3, L4), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7))
     
   }
-  implicit def `T4+T4`[L1, L2, L3, L4, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4), (L1, L2, L3, L4, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4)] {
+  implicit def `T4+T4`[L1, L2, L3, L4, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4), (L1, L2, L3, L4, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4)): ((L1, L2, L3, L4), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8))
     
   }
-  implicit def `T4+T5`[L1, L2, L3, L4, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5)] {
+  implicit def `T4+T5`[L1, L2, L3, L4, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9))
     
   }
-  implicit def `T4+T6`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T4+T6`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10))
     
   }
-  implicit def `T4+T7`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T4+T7`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T4+T8`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T4+T8`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T4+T9`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T4+T9`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T4+T10`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T4+T10`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T4+T11`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T4+T11`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T4+T12`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T4+T12`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T4+T13`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T4+T13`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T4+T14`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+  implicit def `T4+T14`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T4+T15`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+  implicit def `T4+T15`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T4+T16`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+  implicit def `T4+T16`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T4+T17`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+  implicit def `T4+T17`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T4+T18`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Composition.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Composition[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
+  implicit def `T4+T18`[L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18), (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] = new Decompose[(L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)] {
 
     override type Composed = (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)
 
-    def compose(l: (L1, L2, L3, L4), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18) =
-      (l._1, l._2, l._3, l._4, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17, r._18)
-    
     def decompose(c: (L1, L2, L3, L4, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)): ((L1, L2, L3, L4), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17, R18)) =
       ((c._1, c._2, c._3, c._4), (c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T5+T2`[L1, L2, L3, L4, L5, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2), (L1, L2, L3, L4, L5, R1, R2)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2)] {
+  implicit def `T5+T2`[L1, L2, L3, L4, L5, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2), (L1, L2, L3, L4, L5, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2)): (L1, L2, L3, L4, L5, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2)): ((L1, L2, L3, L4, L5), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7))
     
   }
-  implicit def `T5+T3`[L1, L2, L3, L4, L5, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3), (L1, L2, L3, L4, L5, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3)] {
+  implicit def `T5+T3`[L1, L2, L3, L4, L5, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3), (L1, L2, L3, L4, L5, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3)): ((L1, L2, L3, L4, L5), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8))
     
   }
-  implicit def `T5+T4`[L1, L2, L3, L4, L5, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4)] {
+  implicit def `T5+T4`[L1, L2, L3, L4, L5, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9))
     
   }
-  implicit def `T5+T5`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)] {
+  implicit def `T5+T5`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10))
     
   }
-  implicit def `T5+T6`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T5+T6`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T5+T7`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T5+T7`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T5+T8`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T5+T8`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T5+T9`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T5+T9`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T5+T10`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T5+T10`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
-
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
+
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T5+T11`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T5+T11`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T5+T12`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T5+T12`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T5+T13`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T5+T13`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T5+T14`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+  implicit def `T5+T14`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T5+T15`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+  implicit def `T5+T15`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T5+T16`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+  implicit def `T5+T16`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T5+T17`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Composition.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Composition[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
+  implicit def `T5+T17`[L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17]: Decompose.Aux[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17), (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] = new Decompose[(L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)] {
 
     override type Composed = (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)
 
-    def compose(l: (L1, L2, L3, L4, L5), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17) =
-      (l._1, l._2, l._3, l._4, l._5, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16, r._17)
-    
     def decompose(c: (L1, L2, L3, L4, L5, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)): ((L1, L2, L3, L4, L5), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16, R17)) =
       ((c._1, c._2, c._3, c._4, c._5), (c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T6+T2`[L1, L2, L3, L4, L5, L6, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2), (L1, L2, L3, L4, L5, L6, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2)] {
+  implicit def `T6+T2`[L1, L2, L3, L4, L5, L6, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2), (L1, L2, L3, L4, L5, L6, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2)): ((L1, L2, L3, L4, L5, L6), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8))
     
   }
-  implicit def `T6+T3`[L1, L2, L3, L4, L5, L6, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3)] {
+  implicit def `T6+T3`[L1, L2, L3, L4, L5, L6, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9))
     
   }
-  implicit def `T6+T4`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)] {
+  implicit def `T6+T4`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10))
     
   }
-  implicit def `T6+T5`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5)] {
+  implicit def `T6+T5`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T6+T6`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T6+T6`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T6+T7`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T6+T7`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T6+T8`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T6+T8`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T6+T9`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T6+T9`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T6+T10`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T6+T10`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T6+T11`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T6+T11`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T6+T12`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T6+T12`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T6+T13`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T6+T13`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T6+T14`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+  implicit def `T6+T14`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T6+T15`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+  implicit def `T6+T15`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T6+T16`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Composition.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Composition[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
+  implicit def `T6+T16`[L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16]: Decompose.Aux[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16), (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] = new Decompose[(L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15, r._16)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)): ((L1, L2, L3, L4, L5, L6), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15, R16)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6), (c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T7+T2`[L1, L2, L3, L4, L5, L6, L7, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2)] {
+  implicit def `T7+T2`[L1, L2, L3, L4, L5, L6, L7, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9))
     
   }
-  implicit def `T7+T3`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)] {
+  implicit def `T7+T3`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10))
     
   }
-  implicit def `T7+T4`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4)] {
+  implicit def `T7+T4`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11))
     
   }
-  implicit def `T7+T5`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5)] {
+  implicit def `T7+T5`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T7+T6`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T7+T6`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T7+T7`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T7+T7`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T7+T8`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T7+T8`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T7+T9`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T7+T9`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T7+T10`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T7+T10`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T7+T11`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T7+T11`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T7+T12`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T7+T12`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T7+T13`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T7+T13`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T7+T14`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+  implicit def `T7+T14`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T7+T15`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Composition[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
+  implicit def `T7+T15`[L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15), (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14, r._15)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)): ((L1, L2, L3, L4, L5, L6, L7), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R15)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7), (c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T8+T2`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)] {
+  implicit def `T8+T2`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10))
     
   }
-  implicit def `T8+T3`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3)] {
+  implicit def `T8+T3`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11))
     
   }
-  implicit def `T8+T4`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4)] {
+  implicit def `T8+T4`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12))
     
   }
-  implicit def `T8+T5`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5)] {
+  implicit def `T8+T5`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T8+T6`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T8+T6`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T8+T7`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T8+T7`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T8+T8`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T8+T8`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T8+T9`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T8+T9`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T8+T10`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T8+T10`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T8+T11`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T8+T11`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T8+T12`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T8+T12`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T8+T13`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T8+T13`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T8+T14`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
+  implicit def `T8+T14`[L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14), (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13, r._14)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)): ((L1, L2, L3, L4, L5, L6, L7, L8), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8), (c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T9+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2)] {
+  implicit def `T9+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11))
     
   }
-  implicit def `T9+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3)] {
+  implicit def `T9+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12))
     
   }
-  implicit def `T9+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4)] {
+  implicit def `T9+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13))
     
   }
-  implicit def `T9+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5)] {
+  implicit def `T9+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T9+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T9+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T9+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T9+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T9+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T9+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T9+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T9+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T9+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T9+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T9+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T9+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T9+T12`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T9+T12`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T9+T13`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
+  implicit def `T9+T13`[L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13), (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12, r._13)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9), (c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T10+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2)] {
+  implicit def `T10+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12))
     
   }
-  implicit def `T10+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3)] {
+  implicit def `T10+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13))
     
   }
-  implicit def `T10+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4)] {
+  implicit def `T10+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14))
     
   }
-  implicit def `T10+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5)] {
+  implicit def `T10+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T10+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T10+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T10+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T10+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T10+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T10+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T10+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T10+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T10+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T10+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T10+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T10+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T10+T12`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
+  implicit def `T10+T12`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11, r._12)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10), (c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T11+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2)] {
+  implicit def `T11+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13))
     
   }
-  implicit def `T11+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3)] {
+  implicit def `T11+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14))
     
   }
-  implicit def `T11+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4)] {
+  implicit def `T11+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15))
     
   }
-  implicit def `T11+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5)] {
+  implicit def `T11+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T11+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T11+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T11+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T11+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T11+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T11+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T11+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T11+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T11+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T11+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T11+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
+  implicit def `T11+T11`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10, r._11)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11), (c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T12+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2)] {
+  implicit def `T12+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14))
     
   }
-  implicit def `T12+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3)] {
+  implicit def `T12+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15))
     
   }
-  implicit def `T12+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4)] {
+  implicit def `T12+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15, c._16))
     
   }
-  implicit def `T12+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5)] {
+  implicit def `T12+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T12+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T12+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T12+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T12+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T12+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T12+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T12+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T12+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T12+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
+  implicit def `T12+T10`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9, r._10)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12), (R1, R2, R3, R4, R5, R6, R7, R8, R9, R10)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12), (c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T13+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2)] {
+  implicit def `T13+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15))
     
   }
-  implicit def `T13+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3)] {
+  implicit def `T13+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15, c._16))
     
   }
-  implicit def `T13+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4)] {
+  implicit def `T13+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15, c._16, c._17))
     
   }
-  implicit def `T13+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5)] {
+  implicit def `T13+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T13+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T13+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T13+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T13+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T13+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T13+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T13+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
+  implicit def `T13+T9`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8, R9), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8, R9)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), r: (R1, R2, R3, R4, R5, R6, R7, R8, R9)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8, r._9)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, R1, R2, R3, R4, R5, R6, R7, R8, R9)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13), (R1, R2, R3, R4, R5, R6, R7, R8, R9)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13), (c._14, c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T14+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2)] {
+  implicit def `T14+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), (c._15, c._16))
     
   }
-  implicit def `T14+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3)] {
+  implicit def `T14+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), (c._15, c._16, c._17))
     
   }
-  implicit def `T14+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4)] {
+  implicit def `T14+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), (c._15, c._16, c._17, c._18))
     
   }
-  implicit def `T14+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5)] {
+  implicit def `T14+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), (c._15, c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T14+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T14+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), (c._15, c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T14+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T14+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), (c._15, c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T14+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7, R8)] {
+  implicit def `T14+T8`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7, R8), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7, R8)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), r: (R1, R2, R3, R4, R5, R6, R7, R8)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, r._1, r._2, r._3, r._4, r._5, r._6, r._7, r._8)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, R1, R2, R3, R4, R5, R6, R7, R8)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14), (R1, R2, R3, R4, R5, R6, R7, R8)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14), (c._15, c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T15+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2)] {
+  implicit def `T15+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), (c._16, c._17))
     
   }
-  implicit def `T15+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3)] {
+  implicit def `T15+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), (c._16, c._17, c._18))
     
   }
-  implicit def `T15+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4)] {
+  implicit def `T15+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), (c._16, c._17, c._18, c._19))
     
   }
-  implicit def `T15+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5)] {
+  implicit def `T15+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), (c._16, c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T15+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T15+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), (c._16, c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T15+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6, R7)] {
+  implicit def `T15+T7`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6, R7), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6, R7)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), r: (R1, R2, R3, R4, R5, R6, R7)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, r._1, r._2, r._3, r._4, r._5, r._6, r._7)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, R1, R2, R3, R4, R5, R6, R7)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15), (R1, R2, R3, R4, R5, R6, R7)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15), (c._16, c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T16+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2)] {
+  implicit def `T16+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), (c._17, c._18))
     
   }
-  implicit def `T16+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3)] {
+  implicit def `T16+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), (c._17, c._18, c._19))
     
   }
-  implicit def `T16+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4)] {
+  implicit def `T16+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), (c._17, c._18, c._19, c._20))
     
   }
-  implicit def `T16+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5)] {
+  implicit def `T16+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), (c._17, c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T16+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5, R6)] {
+  implicit def `T16+T6`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5, R6), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5, R6)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), r: (R1, R2, R3, R4, R5, R6)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, r._1, r._2, r._3, r._4, r._5, r._6)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, R1, R2, R3, R4, R5, R6)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16), (R1, R2, R3, R4, R5, R6)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16), (c._17, c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T17+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2)] {
+  implicit def `T17+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), (c._18, c._19))
     
   }
-  implicit def `T17+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3)] {
+  implicit def `T17+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), (c._18, c._19, c._20))
     
   }
-  implicit def `T17+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4)] {
+  implicit def `T17+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), (c._18, c._19, c._20, c._21))
     
   }
-  implicit def `T17+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4, R5)] {
+  implicit def `T17+T5`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4, R5), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4, R5)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), r: (R1, R2, R3, R4, R5)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, r._1, r._2, r._3, r._4, r._5)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, R1, R2, R3, R4, R5)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17), (R1, R2, R3, R4, R5)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17), (c._18, c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T18+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2)] {
+  implicit def `T18+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), (c._19, c._20))
     
   }
-  implicit def `T18+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3)] {
+  implicit def `T18+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), (c._19, c._20, c._21))
     
   }
-  implicit def `T18+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3, R4)] {
+  implicit def `T18+T4`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3, R4), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3, R4)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), r: (R1, R2, R3, R4)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, r._1, r._2, r._3, r._4)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, R1, R2, R3, R4)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18), (R1, R2, R3, R4)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18), (c._19, c._20, c._21, c._22))
     
   }
-  implicit def `T19+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2)] {
+  implicit def `T19+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19), (c._20, c._21))
     
   }
-  implicit def `T19+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2, R3)] {
+  implicit def `T19+T3`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2, R3), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2, R3)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), r: (R1, R2, R3)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, r._1, r._2, r._3)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, R1, R2, R3)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19), (R1, R2, R3)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19), (c._20, c._21, c._22))
     
   }
-  implicit def `T20+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2]: Composition.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2)] = new Composition[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), (R1, R2)] {
+  implicit def `T20+T2`[L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2]: Decompose.Aux[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), (R1, R2), (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2)] = new Decompose[(L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), (R1, R2)] {
 
     override type Composed = (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2)
 
-    def compose(l: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), r: (R1, R2)): (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2) =
-      (l._1, l._2, l._3, l._4, l._5, l._6, l._7, l._8, l._9, l._10, l._11, l._12, l._13, l._14, l._15, l._16, l._17, l._18, l._19, l._20, r._1, r._2)
-    
     def decompose(c: (L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20, R1, R2)): ((L1, L2, L3, L4, L5, L6, L7, L8, L9, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19, L20), (R1, R2)) =
       ((c._1, c._2, c._3, c._4, c._5, c._6, c._7, c._8, c._9, c._10, c._11, c._12, c._13, c._14, c._15, c._16, c._17, c._18, c._19, c._20), (c._21, c._22))
     
   }
-  implicit def `unit+A`[A]: Composition.Aux[Unit, A, A] = new Composition[Unit, A] {
+}
 
-    override type Composed = A
+trait Decompose_Pri10 extends Decompose_Pri9 {
 
-    def compose(l: Unit, r: A): A =
-      r
+  implicit def `T1+T1`[L, R]: Decompose.Aux[Tuple1[L], Tuple1[R], Tuple2[L, R]] = new Decompose[Tuple1[L], Tuple1[R]] {
+
+    override type Composed = Tuple2[L, R]
+
+    def decompose(c: Tuple2[L, R]): (Tuple1[L], Tuple1[R]) =
+      (Tuple1(c._1), Tuple1(c._2))
+    
+  }
+
+  implicit def `T2+T1`[T1, T2, R]: Decompose.Aux[(T1, T2), Tuple1[R], (T1, T2, R)] = new Decompose[(T1, T2), Tuple1[R]] {
+
+    override type Composed = (T1, T2, R)
+
+    def decompose(c: (T1, T2, R)): ((T1, T2), Tuple1[R]) =
+      ((c._1, c._2), Tuple1(c._3))
+    
+  }
+  implicit def `T1+T2`[L, T1, T2]: Decompose.Aux[Tuple1[L], (T1, T2), (L, T1, T2)] = new Decompose[Tuple1[L], (T1, T2)] {
+
+    override type Composed = (L, T1, T2)
+
+    def decompose(c: (L, T1, T2)): (Tuple1[L], (T1, T2)) =
+      (Tuple1(c._1), (c._2, c._3))
+    
+  }
+  implicit def `T3+T1`[T1, T2, T3, R]: Decompose.Aux[(T1, T2, T3), Tuple1[R], (T1, T2, T3, R)] = new Decompose[(T1, T2, T3), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, R)
+
+    def decompose(c: (T1, T2, T3, R)): ((T1, T2, T3), Tuple1[R]) =
+      ((c._1, c._2, c._3), Tuple1(c._4))
+    
+  }
+  implicit def `T1+T3`[L, T1, T2, T3]: Decompose.Aux[Tuple1[L], (T1, T2, T3), (L, T1, T2, T3)] = new Decompose[Tuple1[L], (T1, T2, T3)] {
+
+    override type Composed = (L, T1, T2, T3)
+
+    def decompose(c: (L, T1, T2, T3)): (Tuple1[L], (T1, T2, T3)) =
+      (Tuple1(c._1), (c._2, c._3, c._4))
+    
+  }
+  implicit def `T4+T1`[T1, T2, T3, T4, R]: Decompose.Aux[(T1, T2, T3, T4), Tuple1[R], (T1, T2, T3, T4, R)] = new Decompose[(T1, T2, T3, T4), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, R)
+
+    def decompose(c: (T1, T2, T3, T4, R)): ((T1, T2, T3, T4), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4), Tuple1(c._5))
+    
+  }
+  implicit def `T1+T4`[L, T1, T2, T3, T4]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4), (L, T1, T2, T3, T4)] = new Decompose[Tuple1[L], (T1, T2, T3, T4)] {
+
+    override type Composed = (L, T1, T2, T3, T4)
+
+    def decompose(c: (L, T1, T2, T3, T4)): (Tuple1[L], (T1, T2, T3, T4)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5))
+    
+  }
+  implicit def `T5+T1`[T1, T2, T3, T4, T5, R]: Decompose.Aux[(T1, T2, T3, T4, T5), Tuple1[R], (T1, T2, T3, T4, T5, R)] = new Decompose[(T1, T2, T3, T4, T5), Tuple1[R]] {
+
+    override type Composed = (T1, T2, T3, T4, T5, R)
+
+    def decompose(c: (T1, T2, T3, T4, T5, R)): ((T1, T2, T3, T4, T5), Tuple1[R]) =
+      ((c._1, c._2, c._3, c._4, c._5), Tuple1(c._6))
+    
+  }
+  implicit def `T1+T5`[L, T1, T2, T3, T4, T5]: Decompose.Aux[Tuple1[L], (T1, T2, T3, T4, T5), (L, T1, T2, T3, T4, T5)] = new Decompose[Tuple1[L], (T1, T2, T3, T4, T5)] {
+
+    override type Composed = (L, T1, T2, T3, T4, T5)
+
+    def decompose(c: (L, T1, T2, T3, T4, T5)): (Tuple1[L], (T1, T2, T3, T4, T5)) =
+      (Tuple1(c._1), (c._2, c._3, c._4, c._5, c._6))
     
+  }
+  implicit def `T2+T2`[L1, L2, R1, R2]: Decompose.Aux[(L1, L2), (R1, R2), (L1, L2, R1, R2)] = new Decompose[(L1, L2), (R1, R2)] {
+
+    override type Composed = (L1, L2, R1, R2)
+
+    def decompose(c: (L1, L2, R1, R2)): ((L1, L2), (R1, R2)) =
+      ((c._1, c._2), (c._3, c._4))
+    
+  }
+  implicit def `T2+T3`[L1, L2, R1, R2, R3]: Decompose.Aux[(L1, L2), (R1, R2, R3), (L1, L2, R1, R2, R3)] = new Decompose[(L1, L2), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, R1, R2, R3)
+
+    def decompose(c: (L1, L2, R1, R2, R3)): ((L1, L2), (R1, R2, R3)) =
+      ((c._1, c._2), (c._3, c._4, c._5))
+    
+  }
+  implicit def `T2+T4`[L1, L2, R1, R2, R3, R4]: Decompose.Aux[(L1, L2), (R1, R2, R3, R4), (L1, L2, R1, R2, R3, R4)] = new Decompose[(L1, L2), (R1, R2, R3, R4)] {
+
+    override type Composed = (L1, L2, R1, R2, R3, R4)
+
+    def decompose(c: (L1, L2, R1, R2, R3, R4)): ((L1, L2), (R1, R2, R3, R4)) =
+      ((c._1, c._2), (c._3, c._4, c._5, c._6))
+    
+  }
+  implicit def `T3+T2`[L1, L2, L3, R1, R2]: Decompose.Aux[(L1, L2, L3), (R1, R2), (L1, L2, L3, R1, R2)] = new Decompose[(L1, L2, L3), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, R1, R2)
+
+    def decompose(c: (L1, L2, L3, R1, R2)): ((L1, L2, L3), (R1, R2)) =
+      ((c._1, c._2, c._3), (c._4, c._5))
+    
+  }
+  implicit def `T3+T3`[L1, L2, L3, R1, R2, R3]: Decompose.Aux[(L1, L2, L3), (R1, R2, R3), (L1, L2, L3, R1, R2, R3)] = new Decompose[(L1, L2, L3), (R1, R2, R3)] {
+
+    override type Composed = (L1, L2, L3, R1, R2, R3)
+
+    def decompose(c: (L1, L2, L3, R1, R2, R3)): ((L1, L2, L3), (R1, R2, R3)) =
+      ((c._1, c._2, c._3), (c._4, c._5, c._6))
+    
+  }
+  implicit def `T4+T2`[L1, L2, L3, L4, R1, R2]: Decompose.Aux[(L1, L2, L3, L4), (R1, R2), (L1, L2, L3, L4, R1, R2)] = new Decompose[(L1, L2, L3, L4), (R1, R2)] {
+
+    override type Composed = (L1, L2, L3, L4, R1, R2)
+
+    def decompose(c: (L1, L2, L3, L4, R1, R2)): ((L1, L2, L3, L4), (R1, R2)) =
+      ((c._1, c._2, c._3, c._4), (c._5, c._6))
+    
+  }
+  implicit def `unit+A`[A]: Decompose.Aux[Unit, A, A] = new Decompose[Unit, A] {
+
+    override type Composed = A
+
     def decompose(c: A): (Unit, A) =
       ((), c)
     
   }
-  implicit def `A+unit`[A]: Composition.Aux[A, Unit, A] = new Composition[A, Unit] {
+  implicit def `A+unit`[A]: Decompose.Aux[A, Unit, A] = new Decompose[A, Unit] {
 
     override type Composed = A
 
-    def compose(l: A, r: Unit): A =
-      l
-    
     def decompose(c: A): (A, Unit) =
       (c, ())
     
@@ -3065,19 +4485,43 @@ trait Composition_Pri10 extends Composition_Pri7 {
 
 }
 
-object Composition extends Composition_Pri10 {
-  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
+object Compose extends Compose_Pri10 {
+  type Aux[A, B, O] = Compose[A, B] { type Composed = O }
 
-  implicit def `unit+unit`: Composition.Aux[Unit, Unit, Unit] = new Composition[Unit, Unit] {
+  implicit def `unit+unit`: Compose.Aux[Unit, Unit, Unit] = new Compose[Unit, Unit] {
 
     override type Composed = Unit
 
     def compose(l: Unit, r: Unit): Unit =
       ()
     
+  }
+
+}
+
+object Decompose extends Decompose_Pri10 {
+  type Aux[A, B, O] = Decompose[A, B] { type Composed = O }
+
+  implicit def `unit+unit`: Decompose.Aux[Unit, Unit, Unit] = new Decompose[Unit, Unit] {
+
+    override type Composed = Unit
+
     def decompose(c: Unit): (Unit, Unit) =
       ((), ())
     
   }
 
 }
+
+object Composition {
+  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
+
+  implicit def implied[A, B, O](implicit c: Compose.Aux[A, B, O], d: Decompose.Aux[A, B, O]): Composition.Aux[A, B, O] = {
+    new Composition[A, B] {
+      override type Composed = O
+
+      def compose(l: A, r: B): O = c.compose(l, r)
+      def decompose(c: O): (A, B) = d.decompose(c)
+    }
+  }
+}
diff --git a/modules/shared/src/main/scala-3/app/tulz/tuplez/TupleComposition.scala b/modules/shared/src/main/scala-3/app/tulz/tuplez/TupleComposition.scala
new file mode 100644
index 0000000..12cc2da
--- /dev/null
+++ b/modules/shared/src/main/scala-3/app/tulz/tuplez/TupleComposition.scala
@@ -0,0 +1,203 @@
+package app.tulz.tuplez
+
+import scala.util.NotGiven
+
+object TupleComposition {
+
+  def compose[L, R](l: L, r: R)(using composition: Compose[L, R]): composition.Composed = composition.compose(l, r)
+  def decompose[L, R, C](c: C)(using composition: Decompose.Aux[L, R, C]): (L, R)       = composition.decompose(c)
+
+}
+
+trait Compose[-L, -R] {
+  type Composed
+  def compose(a: L, b: R): Composed
+}
+
+
+trait Decompose[L, R] {
+  type Composed
+  def decompose(c: Composed): (L, R)
+}
+
+abstract class Composition[L, R] extends Compose[L, R], Decompose[L, R] {
+  type Composed
+}
+
+object Composition {
+
+  type Aux[A, B, O] = Composition[A, B] { type Composed = O }
+
+  given implied[A, B, O](using c: Compose.Aux[A, B, O], d: Decompose.Aux[A, B, O]): Composition.Aux[A, B, O] =
+    new Composition[A, B] {
+      override type Composed = O
+
+      def compose(l: A, r: B): O = c.compose(l, r)
+      def decompose(c: O): (A, B) = d.decompose(c)
+    }
+
+}
+
+// ---- compose givens
+
+trait Compose_Pri0 {
+  given `***`[A, B]: Compose.Aux[A, B, Tuple2[A, B]] = new Compose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
+    def compose(l: A, r: B): Tuple2[A, B] =
+      Tuple2(l, r)
+
+  }
+}
+
+trait Compose_Pri10 extends Compose_Pri0 {
+
+  given `T+Scalar`[T1 <: Tuple, T2]: Compose.Aux[T1, T2, Tuple.Append[T1, T2]] = new Compose[T1, T2] {
+
+    override type Composed = Tuple.Append[T1, T2]
+
+    def compose(l: T1, r: T2): Tuple.Append[T1, T2] =
+      l :* r
+
+  }
+
+  given `Scalar+T`[T1, T2 <: Tuple]: Compose.Aux[T1, T2, Tuple.Concat[Tuple1[T1], T2]] = new Compose[T1, T2] {
+
+    override type Composed = Tuple.Concat[Tuple1[T1], T2]
+
+    def compose(l: T1, r: T2): Tuple.Concat[Tuple1[T1], T2] =
+      l *: r
+
+  }
+
+}
+
+object Compose extends Compose_Pri10 {
+
+  type Aux[A, B, O] = Compose[A, B] { type Composed = O }
+
+  given `unit+unit`: Compose.Aux[Unit, Unit, Unit] = new Compose[Unit, Unit] {
+
+    override type Composed = Unit
+
+    def compose(l: Unit, r: Unit): Unit =
+      ()
+
+  }
+
+  given `unit+A`[A]: Compose.Aux[Unit, A, A] = new Compose[Unit, A] {
+
+    override type Composed = A
+
+    def compose(l: Unit, r: A): A =
+      r
+
+  }
+
+  given `A+unit`[A]: Compose.Aux[A, Unit, A] = new Compose[A, Unit] {
+
+    override type Composed = A
+
+    def compose(l: A, r: Unit): A =
+      l
+
+  }
+
+  given `T+T`[T1 <: Tuple, T2 <: Tuple]: Compose.Aux[T1, T2, Tuple.Concat[T1, T2]] = new Compose[T1, T2] {
+
+    override type Composed = Tuple.Concat[T1, T2]
+
+    def compose(l: T1, r: T2): Tuple.Concat[T1, T2] =
+      l ++ r
+
+  }
+
+}
+
+// ---- decompose givens
+
+trait Decompose_Pri0 {
+  given `***`[A, B]: Decompose.Aux[A, B, Tuple2[A, B]] = new Decompose[A, B] {
+
+    override type Composed = Tuple2[A, B]
+
+    def decompose(c: Tuple2[A, B]): (A, B) =
+      c
+
+  }
+}
+
+trait Decompose_Pri10 extends Decompose_Pri0 {
+
+
+  given `T+Scalar`[T1 <: Tuple, T2](using NotGiven[T2 <:< Tuple]): Decompose.Aux[T1, T2, Tuple.Append[T1, T2]] = new Decompose[T1, T2] {
+
+    override type Composed = Tuple.Append[T1, T2]
+
+    def decompose(c: Tuple.Append[T1, T2]): (T1, T2) = {
+      val left = c.init.asInstanceOf[T1]
+      val right = c.last.asInstanceOf[T2] // c.drop(size1).productElement(0).asInstanceOf[T2] // Get the single element
+      (left, right)
+    }
+
+  }
+
+  given `Scalar+T`[T1, T2 <: Tuple](using NotGiven[T1 <:< Tuple]): Decompose.Aux[T1, T2, Tuple.Concat[Tuple1[T1], T2]] = new Decompose[T1, T2] {
+
+    override type Composed = Tuple.Concat[Tuple1[T1], T2]
+
+    def decompose(c: Tuple.Concat[Tuple1[T1], T2]): (T1, T2) = {
+      val left = c.head
+      val right = c.tail
+      (left, right)
+    }
+
+  }
+
+  given `T+T`[T1 <: Tuple, T2 <: Tuple](using ValueOf[Tuple.Size[T1]]): Decompose.Aux[T1, T2, Tuple.Concat[T1, T2]] = new Decompose[T1, T2] {
+
+    override type Composed = Tuple.Concat[T1, T2]
+
+    def decompose(c: Tuple.Concat[T1, T2]): (T1, T2) = {
+      val size1 = valueOf[Tuple.Size[T1]]
+      val (left, right) = c.splitAt(size1)
+      (left.asInstanceOf[T1], right.asInstanceOf[T2])
+    }
+
+  }
+
+}
+
+object Decompose extends Decompose_Pri10 {
+
+  type Aux[A, B, O] = Decompose[A, B] { type Composed = O }
+
+  given `unit+unit`: Decompose.Aux[Unit, Unit, Unit] = new Decompose[Unit, Unit] {
+
+    override type Composed = Unit
+
+    def decompose(c: Unit): (Unit, Unit) =
+      ((), ())
+
+  }
+
+  given `unit+A`[A]: Decompose.Aux[Unit, A, A] = new Decompose[Unit, A] {
+
+    override type Composed = A
+
+    def decompose(c: A): (Unit, A) =
+      ((), c)
+
+  }
+
+  given `A+unit`[A]: Decompose.Aux[A, Unit, A] = new Decompose[A, Unit] {
+
+    override type Composed = A
+
+    def decompose(c: A): (A, Unit) =
+      (c, ())
+
+  }
+
+}
diff --git a/project/ApplyConverterTestGenerator.scala b/project/ApplyConverterTestGenerator.scala
index 1e1bc17..277bc67 100644
--- a/project/ApplyConverterTestGenerator.scala
+++ b/project/ApplyConverterTestGenerator.scala
@@ -33,7 +33,7 @@ class ApplyConverterTestGenerator(sourceManaged: File)
         val values        = tupleValue(size, 0)
         val tupleToString = (1 to size).map(i => s"$i").mkString(",")
 
-        enter(s"""@Test @annotation.nowarn def `converter for Tuple${size}`(): Unit = {""")("}") {
+        enter(s"""@Test def `converter for Tuple${size}`(): Unit = {""")("}") {
           println(s"""val acceptingTupledFunc: (Tuple${size}[${tpe}] => String) => String = func => func(${values})""")
           println(s"""assertEquals("should match", "${tupleToString}", acceptingTupledFunc(toTupled${size}((${args}) => s"${argsToString}")))""")
         }
diff --git a/project/ScalaOptions.scala b/project/ScalaOptions.scala
deleted file mode 100644
index 32db9ca..0000000
--- a/project/ScalaOptions.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-import sbt._
-import sbt.Keys._
-
-object ScalaOptions {
-
-  val fixOptions: Setting[_] = {
-    scalacOptions ++= (CrossVersion.partialVersion(scalaVersion.value) match {
-      case Some((2, 12)) =>
-        Seq(
-          "-feature",
-          "-unchecked",
-          "-language:existentials",
-          "-language:experimental.macros",
-          "-language:higherKinds",
-          "-language:implicitConversions",
-          "-Xlint:adapted-args",
-          "-Xlint:constant",
-          "-Xlint:delayedinit-select",
-          "-Xlint:deprecation",
-          "-Xlint:doc-detached",
-          "-Xlint:inaccessible",
-          "-Xlint:infer-any",
-          "-Xlint:missing-interpolator",
-          "-Xlint:nullary-unit",
-          "-Xlint:option-implicit",
-          "-Xlint:package-object-classes",
-          "-Xlint:poly-implicit-overload",
-          "-Xlint:private-shadow",
-          "-Xlint:stars-align",
-          "-Xlint:type-parameter-shadow",
-          "-Xfatal-warnings",
-        )
-      case Some((2, 13)) =>
-        Seq(
-          "-feature",
-          "-unchecked",
-          "-language:existentials",
-          "-language:experimental.macros",
-          "-language:higherKinds",
-          "-language:implicitConversions",
-          "-Xlint:adapted-args",
-          "-Xlint:constant",
-          "-Xlint:delayedinit-select",
-          "-Xlint:deprecation",
-          "-Xlint:doc-detached",
-          "-Xlint:implicit-recursion",
-          "-Xlint:implicit-not-found",
-          "-Xlint:inaccessible",
-          "-Xlint:infer-any",
-          "-Xlint:missing-interpolator",
-          "-Xlint:nullary-unit",
-          "-Xlint:option-implicit",
-          "-Xlint:package-object-classes",
-          "-Xlint:poly-implicit-overload",
-          "-Xlint:private-shadow",
-          "-Xlint:stars-align",
-          "-Xlint:strict-unsealed-patmat",
-          "-Xlint:type-parameter-shadow",
-          "-Xlint:-byname-implicit",
-          "-Wextra-implicit",
-          "-Wnumeric-widen",
-          "-Wvalue-discard",
-          "-Wunused:nowarn",
-          "-Wunused:locals",
-          "-Wunused:patvars",
-          "-Xfatal-warnings",
-        )
-
-      case Some((3, _)) =>
-        Seq(
-          "-deprecation",
-          "-feature",
-          "-unchecked",
-          "-language:higherKinds",
-          "-language:implicitConversions",
-          "-Ykind-projector",
-          "-Xfatal-warnings"
-        )
-
-      case _ => throw new RuntimeException(s"unexpected scalaVersion: ${scalaVersion.value}")
-
-    })
-  }
-
-}
diff --git a/project/ScalaVersions.scala b/project/ScalaVersions.scala
index 90ab4fb..1801f0a 100644
--- a/project/ScalaVersions.scala
+++ b/project/ScalaVersions.scala
@@ -1,5 +1,5 @@
 object ScalaVersions {
-  val v213 = "2.13.10"
-  val v212 = "2.12.17"
-  val v3   = "3.2.1"
+  val v213 = "2.13.18"
+  val v212 = "2.12.21"
+  val v3   = "3.3.7"
 }
diff --git a/project/SharedSourceDir.scala b/project/SharedSourceDir.scala
index 5b6fb25..53d2bcc 100644
--- a/project/SharedSourceDir.scala
+++ b/project/SharedSourceDir.scala
@@ -9,7 +9,9 @@ object SharedSourceDir extends AutoPlugin {
 
   object autoImport {
 
-    val sharedScalaSource = settingKey[File]("slf4j").withRank(KeyRanks.Invisible)
+    val sharedScalaSource = settingKey[File]("shared source dir").withRank(KeyRanks.Invisible)
+    val sharedScala2Source = settingKey[File]("shared scala 2 source dir").withRank(KeyRanks.Invisible)
+    val sharedScala3Source = settingKey[File]("shared scala 3 source dir").withRank(KeyRanks.Invisible)
 
   }
 
@@ -21,7 +23,15 @@ object SharedSourceDir extends AutoPlugin {
       !string.contains(".js") &&
       !string.contains(".jvm") &&
       !string.contains("scala-")
-    }.get
+    }.get,
+    sharedScala2Source := {
+      val f = sharedScalaSource.value
+      new File(f.getAbsolutePath + "-2")
+    },
+    sharedScala3Source := {
+      val f = sharedScalaSource.value
+      new File(f.getAbsolutePath + "-3")
+    },
   )
 
 }
diff --git a/project/TupleCompositionGenerator.scala b/project/TupleCompositionGenerator.scala
index 0e053b8..30af1c8 100644
--- a/project/TupleCompositionGenerator.scala
+++ b/project/TupleCompositionGenerator.scala
@@ -2,27 +2,41 @@ import sbt._
 
 import java.io.File
 
-class TupleCompositionGenerator(sourceManaged: File, to: Int, generateConcats: Boolean, generatePrepends: Boolean)
+class TupleCompositionGenerator(sourceManaged: File, to: Int, splitPriorityAt: Int, generateConcats: Boolean, generatePrepends: Boolean)
     extends SourceGenerator(
       sourceManaged / "app" / "tulz" / "tuplez" / "TupleComposition.scala"
     ) {
 
-  private def newComposition(
+  private def newCompose(
     name: String,
     typeParams: String,
     L: String,
     R: String,
     O: String,
     compose: String,
-    decompose: String,
   ): Unit = {
-    enter(s"""implicit def `$name`${if (typeParams.nonEmpty) s"[$typeParams]" else ""}: Composition.Aux[$L, $R, $O] = new Composition[$L, $R] {""")("}") {
+    enter(s"""implicit def `$name`${if (typeParams.nonEmpty) s"[$typeParams]" else ""}: Compose.Aux[$L, $R, $O] = new Compose[$L, $R] {""")("}") {
       println()
       println(s"override type Composed = ${O}")
       println()
       enter(s"def compose(l: $L, r: $R): $O =")("") {
         println(compose)
       }
+    }
+  }
+
+  private def newDecompose(
+    name: String,
+    typeParams: String,
+    L: String,
+    R: String,
+    O: String,
+    decompose: String,
+  ): Unit = {
+    enter(s"""implicit def `$name`${if (typeParams.nonEmpty) s"[$typeParams]" else ""}: Decompose.Aux[$L, $R, $O] = new Decompose[$L, $R] {""")("}") {
+      println()
+      println(s"override type Composed = ${O}")
+      println()
       enter(s"def decompose(c: $O): ($L, $R) =")("") {
         println(decompose)
       }
@@ -34,207 +48,468 @@ class TupleCompositionGenerator(sourceManaged: File, to: Int, generateConcats: B
     println()
     enter("""object TupleComposition {""")("}") {
       println()
-      println("""def compose[L, R](l: L, r: R)(implicit composition: Composition[L, R]): composition.Composed = composition.compose(l, r)""")
-      println("""def decompose[L, R, C](c: C)(implicit composition: Composition.Aux[L, R, C]): (L, R)         = composition.decompose(c)""".stripMargin)
+      println("""def compose[L, R](l: L, r: R)(implicit composition: Compose[L, R]): composition.Composed = composition.compose(l, r)""")
+      println("""def decompose[L, R, C](c: C)(implicit composition: Decompose.Aux[L, R, C]): (L, R)       = composition.decompose(c)""".stripMargin)
       println()
     }
     println()
-    enter("""abstract class Composition[L, R] {""")("}") {
+
+    enter("""trait Compose[-L, -R] {""")("}") {
       println("""type Composed""")
       println("""def compose(a: L, b: R): Composed""")
+    }
+
+    println()
+
+    enter("""trait Decompose[L, R] {""")("}") {
+      println("""type Composed""")
       println("""def decompose(c: Composed): (L, R)""")
     }
+
+    println()
+
+    enter("""abstract class Composition[L, R] extends Compose[L, R] with Decompose[L, R] {""")("}") {
+      println("""type Composed""")
+    }
+
     println()
-    enter("""trait Composition_Pri0 {""")("}") {
-      newComposition(
+
+    enter("""trait Compose_Pri0 {""")("}") {
+      newCompose(
         name = "***",
         typeParams = "A, B",
         L = "A",
         R = "B",
         O = "Tuple2[A, B]",
         compose = "Tuple2(l, r)",
-        decompose = "c"
       )
     }
+
+    println()
+
+    enter("""trait Decompose_Pri0 {""")("}") {
+      newDecompose(
+        name = "***",
+        typeParams = "A, B",
+        L = "A",
+        R = "B",
+        O = "Tuple2[A, B]",
+        decompose = "c",
+      )
+    }
+
     println()
 
-    enter("""trait Composition_Pri5 extends Composition_Pri0{""")("}") {
-      newComposition(
+    enter("""trait Compose_Pri5 extends Compose_Pri0 {""")("}") {
+      newCompose(
         name = "T1+R",
         typeParams = "L, R",
         L = "Tuple1[L]",
         R = "R",
         O = "Tuple2[L, R]",
         compose = "Tuple2(l._1, r)",
-        decompose = "Tuple2(Tuple1(c._1), c._2)"
       )
 
-      newComposition(
+      newCompose(
         name = "L+T1",
         typeParams = "L, R",
         L = "L",
         R = "Tuple1[R]",
         O = "Tuple2[L, R]",
         compose = "Tuple2(l, r._1)",
+      )
+    }
+
+    println()
+
+    enter("""trait Decompose_Pri5 extends Decompose_Pri0 {""")("}") {
+      newDecompose(
+        name = "T1+R",
+        typeParams = "L, R",
+        L = "Tuple1[L]",
+        R = "R",
+        O = "Tuple2[L, R]",
+        decompose = "Tuple2(Tuple1(c._1), c._2)"
+      )
+
+      newDecompose(
+        name = "L+T1",
+        typeParams = "L, R",
+        L = "L",
+        R = "Tuple1[R]",
+        O = "Tuple2[L, R]",
         decompose = "Tuple2(c._1, Tuple1(c._2))"
       )
     }
 
     println()
 
-    generatePri7(to, generatePrepends)
+    generateComposePri7()
 
     println()
 
-    generatePri10(to, generateConcats)
+    generateDecomposePri7()
 
     println()
 
-    enter("""object Composition extends Composition_Pri10 {""")("}") {
-      println("""type Aux[A, B, O] = Composition[A, B] { type Composed = O }""")
+    generateComposePri10()
+
+    println()
+
+    generateDecomposePri10()
+
+    println()
+
+    enter("""object Compose extends Compose_Pri10 {""")("}") {
+      println("""type Aux[A, B, O] = Compose[A, B] { type Composed = O }""")
       println()
 
-      newComposition(
+      newCompose(
         name = "unit+unit",
         typeParams = "",
         L = "Unit",
         R = "Unit",
         O = "Unit",
         compose = "()",
+      )
+
+      println()
+    }
+    println()
+
+    enter("""object Decompose extends Decompose_Pri10 {""")("}") {
+      println("""type Aux[A, B, O] = Decompose[A, B] { type Composed = O }""")
+      println()
+
+      newDecompose(
+        name = "unit+unit",
+        typeParams = "",
+        L = "Unit",
+        R = "Unit",
+        O = "Unit",
         decompose = "((), ())"
       )
 
       println()
+
+    }
+
+    println()
+
+    enter("""object Composition {""")("}") {
+      println("""type Aux[A, B, O] = Composition[A, B] { type Composed = O }""")
+      println()
+      enter("""implicit def implied[A, B, O](implicit c: Compose.Aux[A, B, O], d: Decompose.Aux[A, B, O]): Composition.Aux[A, B, O] = {""")("}") {
+        enter("""new Composition[A, B] {""")("}") {
+          println("""override type Composed = O""")
+          println()
+          println("""def compose(l: A, r: B): O = c.compose(l, r)""")
+          println("""def decompose(c: O): (A, B) = d.decompose(c)""")
+        }
+      }
     }
   }
 
-  def generatePri7(to: Int, generatePrepends: Boolean): Unit = {
+  def generateComposeSizeAndScalar(minArity: Int, maxArity: Int, priority: Int, extendsPriority: Int): Unit = {
     def forSizeAndScalar(size: Int): Unit = {
       val left = tupleType(size - 1)
-      newComposition(
+      newCompose(
         name = s"T${size - 1}+scalar",
         typeParams = s"${left}, R",
         L = s"(${left})",
         R = s"R",
         O = s"(${left}, R)",
         compose = s"(${tupleAccess(size - 1, "l")}, r)",
-        decompose = s"((${tupleAccess(size - 1, "c")}), c._${size})"
       )
     }
 
     def forScalarAndSize(size: Int): Unit = {
       val right = tupleType(size - 1)
-      newComposition(
+      newCompose(
         name = s"scalar+T${size - 1}",
         typeParams = s"L, ${right}",
         L = s"L",
         R = s"(${right})",
         O = s"(L, ${right})",
         compose = s"(l, ${tupleAccess(size - 1, "r")})",
+      )
+    }
+
+    enter(s"""trait Compose_Pri${priority} extends Compose_Pri${extendsPriority} {""")("}") {
+      println()
+      for (size <- 3 to to) {
+        if (size >= minArity && size <= maxArity) {
+          forSizeAndScalar(size)
+          if (generatePrepends) {
+            forScalarAndSize(size)
+          }
+        }
+      }
+    }
+  }
+
+  def generateDecomposeSizeAndScalar(minArity: Int, maxArity: Int, priority: Int, extendsPriority: Int): Unit = {
+    def forSizeAndScalar(size: Int): Unit = {
+      val left = tupleType(size - 1)
+      newDecompose(
+        name = s"T${size - 1}+scalar",
+        typeParams = s"${left}, R",
+        L = s"(${left})",
+        R = s"R",
+        O = s"(${left}, R)",
+        decompose = s"((${tupleAccess(size - 1, "c")}), c._${size})"
+      )
+    }
+
+    def forScalarAndSize(size: Int): Unit = {
+      val right = tupleType(size - 1)
+      newDecompose(
+        name = s"scalar+T${size - 1}",
+        typeParams = s"L, ${right}",
+        L = s"L",
+        R = s"(${right})",
+        O = s"(L, ${right})",
         decompose = s"(c._1, (${tupleAccess(2, size, "c")}))"
       )
     }
 
-    enter("""trait Composition_Pri7 extends Composition_Pri5 {""")("}") {
+    enter(s"""trait Decompose_Pri${priority} extends Decompose_Pri${extendsPriority} {""")("}") {
       println()
       for (size <- 3 to to) {
-        forSizeAndScalar(size)
-        if (generatePrepends) {
-          forScalarAndSize(size)
+        if (size >= minArity && size <= maxArity) {
+          forSizeAndScalar(size)
+          if (generatePrepends) {
+            forScalarAndSize(size)
+          }
         }
       }
     }
   }
 
-  def generatePri10(to: Int, generateConcats: Boolean): Unit = {
+  def generateComposePri7(): Unit = {
+    if (splitPriorityAt < to) {
+      generateComposeSizeAndScalar(minArity = splitPriorityAt + 1, maxArity = Int.MaxValue, priority = 6, extendsPriority = 5)
+      println()
+      generateComposeSizeAndScalar(minArity = 1, maxArity = splitPriorityAt, priority = 7, extendsPriority = 6)
+    } else {
+      generateComposeSizeAndScalar(minArity = 1, maxArity = Int.MaxValue, priority = 7, extendsPriority = 5)
+    }
+  }
+  def generateDecomposePri7(): Unit = {
+    if (splitPriorityAt < to) {
+      generateDecomposeSizeAndScalar(minArity = splitPriorityAt + 1, maxArity = Int.MaxValue, priority = 6, extendsPriority = 5)
+      println()
+      generateDecomposeSizeAndScalar(minArity = 1, maxArity = splitPriorityAt, priority = 7, extendsPriority = 6)
+    } else {
+      generateDecomposeSizeAndScalar(minArity = 1, maxArity = Int.MaxValue, priority = 7, extendsPriority = 5)
+    }
+  }
+
+  def generateComposeHighPriority(minArity: Int, maxArity: Int, priority: Int, extendsPriority: Int): Unit = {
 
     def forSizeAnd1(size: Int): Unit = {
       val left = tupleType(size)
-      newComposition(
+      newCompose(
         name = s"T${size}+T1",
         typeParams = s"${left}, R",
         L = s"(${left})",
         R = s"Tuple1[R]",
         O = s"(${left}, R)",
         compose = s"(${tupleAccess(size, "l")}, r._1)",
-        decompose = s"((${tupleAccess(1, size, "c")}), Tuple1(c._${size + 1}))"
       )
     }
 
     def for1AndSize(size: Int): Unit = {
       val right = tupleType(size)
-      newComposition(
+      newCompose(
         name = s"T1+T${size}",
         typeParams = s"L, ${right}",
         L = s"Tuple1[L]",
         R = s"(${right})",
         O = s"(L, ${right})",
         compose = s"(l._1, ${tupleAccess(size, "r")})",
-        decompose = s"(Tuple1(c._1), (${tupleAccess(2, size + 1, "c")}))"
       )
     }
 
     def forSizes(size1: Int, size2: Int): Unit = {
       val left  = tupleType(size1, "L")
       val right = tupleType(size2, "R")
-      newComposition(
+      newCompose(
         name = s"T${size1}+T${size2}",
         typeParams = s"${left}, ${right}",
         L = s"(${left})",
         R = s"(${right})",
         O = s"(${left}, ${right})",
         compose = s"(${tupleAccess(size1, "l")}, ${tupleAccess(size2, "r")})",
-        decompose = s"((${tupleAccess(1, size1, "c")}), (${tupleAccess(size1 + 1, size1 + size2, "c")}))"
       )
     }
 
-    enter("""trait Composition_Pri10 extends Composition_Pri7 {""")("}") {
+    enter(s"""trait Compose_Pri${priority} extends Compose_Pri${extendsPriority} {""")("}") {
       println()
-      newComposition(
-        name = s"T1+T1",
-        typeParams = s"L, R",
-        L = s"Tuple1[L]",
+      if (minArity <= 2) {
+        newCompose(
+          name = s"T1+T1",
+          typeParams = s"L, R",
+          L = s"Tuple1[L]",
+          R = s"Tuple1[R]",
+          O = s"Tuple2[L, R]",
+          compose = s"(l._1, r._1)",
+        )
+        println()
+      }
+
+      for (size <- 2 until to) {
+        if (size + 1 >= minArity && size + 1 <= maxArity) {
+          forSizeAnd1(size)
+          for1AndSize(size)
+        }
+      }
+
+      if (generateConcats) {
+        for (size1 <- 2 to to - 2) {
+          for (size2 <- 2 to to - size1) {
+            if (size1 + size2 >= minArity && size1 + size2 <= maxArity) {
+              forSizes(size1, size2)
+            }
+          }
+        }
+      }
+
+      if (minArity == 1) {
+        newCompose(
+          name = s"unit+A",
+          typeParams = s"A",
+          L = s"Unit",
+          R = s"A",
+          O = s"A",
+          compose = s"r",
+        )
+
+        newCompose(
+          name = s"A+unit",
+          typeParams = s"A",
+          L = s"A",
+          R = s"Unit",
+          O = s"A",
+          compose = s"l",
+        )
+
+        println()
+      }
+    }
+  }
+
+  def generateDecomposeHighPriority(minArity: Int, maxArity: Int, priority: Int, extendsPriority: Int): Unit = {
+
+    def forSizeAnd1(size: Int): Unit = {
+      val left = tupleType(size)
+      newDecompose(
+        name = s"T${size}+T1",
+        typeParams = s"${left}, R",
+        L = s"(${left})",
         R = s"Tuple1[R]",
-        O = s"Tuple2[L, R]",
-        compose = s"(l._1, r._1)",
-        decompose = s"(Tuple1(c._1), Tuple1(c._2))",
+        O = s"(${left}, R)",
+        decompose = s"((${tupleAccess(1, size, "c")}), Tuple1(c._${size + 1}))"
+      )
+    }
+
+    def for1AndSize(size: Int): Unit = {
+      val right = tupleType(size)
+      newDecompose(
+        name = s"T1+T${size}",
+        typeParams = s"L, ${right}",
+        L = s"Tuple1[L]",
+        R = s"(${right})",
+        O = s"(L, ${right})",
+        decompose = s"(Tuple1(c._1), (${tupleAccess(2, size + 1, "c")}))"
+      )
+    }
+
+    def forSizes(size1: Int, size2: Int): Unit = {
+      val left  = tupleType(size1, "L")
+      val right = tupleType(size2, "R")
+      newDecompose(
+        name = s"T${size1}+T${size2}",
+        typeParams = s"${left}, ${right}",
+        L = s"(${left})",
+        R = s"(${right})",
+        O = s"(${left}, ${right})",
+        decompose = s"((${tupleAccess(1, size1, "c")}), (${tupleAccess(size1 + 1, size1 + size2, "c")}))"
       )
+    }
+
+    enter(s"""trait Decompose_Pri${priority} extends Decompose_Pri${extendsPriority} {""")("}") {
       println()
+      if (minArity <= 2) {
+        newDecompose(
+          name = s"T1+T1",
+          typeParams = s"L, R",
+          L = s"Tuple1[L]",
+          R = s"Tuple1[R]",
+          O = s"Tuple2[L, R]",
+          decompose = s"(Tuple1(c._1), Tuple1(c._2))",
+        )
+        println()
+      }
 
       for (size <- 2 until to) {
-        forSizeAnd1(size)
-        for1AndSize(size)
+        if (size + 1 >= minArity && size + 1 <= maxArity) {
+          forSizeAnd1(size)
+          for1AndSize(size)
+        }
       }
 
       if (generateConcats) {
         for (size1 <- 2 to to - 2) {
           for (size2 <- 2 to to - size1) {
-            forSizes(size1, size2)
+            if (size1 + size2 >= minArity && size1 + size2 <= maxArity) {
+              forSizes(size1, size2)
+            }
           }
         }
       }
 
-      newComposition(
-        name = s"unit+A",
-        typeParams = s"A",
-        L = s"Unit",
-        R = s"A",
-        O = s"A",
-        compose = s"r",
-        decompose = s"((), c)"
-      )
+      if (minArity == 1) {
+        newDecompose(
+          name = s"unit+A",
+          typeParams = s"A",
+          L = s"Unit",
+          R = s"A",
+          O = s"A",
+          decompose = s"((), c)"
+        )
 
-      newComposition(
-        name = s"A+unit",
-        typeParams = s"A",
-        L = s"A",
-        R = s"Unit",
-        O = s"A",
-        compose = s"l",
-        decompose = s"(c, ())"
-      )
+        newDecompose(
+          name = s"A+unit",
+          typeParams = s"A",
+          L = s"A",
+          R = s"Unit",
+          O = s"A",
+          decompose = s"(c, ())"
+        )
+
+        println()
+      }
+    }
+  }
+
+  def generateComposePri10(): Unit = {
+    if (splitPriorityAt < to) {
+      generateComposeHighPriority(minArity = splitPriorityAt + 1, maxArity = Int.MaxValue, priority = 9, extendsPriority = 7)
+      println()
+      generateComposeHighPriority(minArity = 1, maxArity = splitPriorityAt, priority = 10, extendsPriority = 9)
+    } else {
+      generateComposeHighPriority(minArity = 1, maxArity = Int.MaxValue, priority = 10, extendsPriority = 7)
+    }
+  }
 
+  def generateDecomposePri10(): Unit = {
+    if (splitPriorityAt < to) {
+      generateDecomposeHighPriority(minArity = splitPriorityAt + 1, maxArity = Int.MaxValue, priority = 9, extendsPriority = 7)
       println()
+      generateDecomposeHighPriority(minArity = 1, maxArity = splitPriorityAt, priority = 10, extendsPriority = 9)
+    } else {
+      generateDecomposeHighPriority(minArity = 1, maxArity = Int.MaxValue, priority = 10, extendsPriority = 7)
     }
   }
 
diff --git a/project/TupleCompositionTestGenerator.scala b/project/TupleCompositionTestGenerator.scala
index 308e74d..1d2d68b 100644
--- a/project/TupleCompositionTestGenerator.scala
+++ b/project/TupleCompositionTestGenerator.scala
@@ -2,11 +2,13 @@ import sbt._
 
 import java.io.File
 
-class TupleCompositionTestGenerator(sourceManaged: File, to: Int, testConcats: Boolean, testPrepends: Boolean)
+class TupleCompositionTestGenerator(sourceManaged: File, to: Int, testConcats: Boolean, testPrepends: Boolean, scala3: Boolean)
     extends SourceGenerator(
       sourceManaged / "app" / "tulz" / "tuplez" / "TupleCompositionTests.scala"
     ) {
 
+  private val summon = if (scala3) "summon" else "implicitly"
+
   def doGenerate(): Unit = {
     println("""package app.tulz.tuplez""")
     println()
@@ -21,33 +23,65 @@ class TupleCompositionTestGenerator(sourceManaged: File, to: Int, testConcats: B
 
       enter("""@Test def `Unit+Unit`(): Unit = {""")("}") {
         println("""assertEquals("composed should match", unit, TupleComposition.compose(unit, unit))""")
+        if (scala3) {
+          println(s"""assertEquals("decomposed should match", (unit, unit), $summon[Decompose[Unit, Unit]].decompose(unit))""")
+          println(s"""assertEquals("decomposed should match", (unit, unit), $summon[Composition[Unit, Unit]].decompose(unit))""")
+        }
       }
 
       println()
 
       enter("""@Test def `scalar+scalar`(): Unit = {""")("}") {
         println("""assertEquals("composed should match", ("1", "2"), TupleComposition.compose("1", "2"))""")
+        if (scala3) { // TODO: scala-2 is not able to figure it out (the decompose.Composed type)
+          println(s"""assertEquals("decomposed should match", ("1", "2"), $summon[Decompose[String, String]].decompose(Tuple2("1", "2")))""")
+          println(s"""assertEquals("decomposed should match", ("1", "2"), $summon[Composition[String, String]].decompose(Tuple2("1", "2")))""")
+        }
       }
 
       println()
 
       enter("""@Test def `scalar+unit`(): Unit = {""")("}") {
         println("""assertEquals("composed should match", "1", TupleComposition.compose("1", unit))""")
+        if (scala3) {
+          println(s"""assertEquals("decomposed should match", ("1", unit), $summon[Decompose[String, Unit]].decompose("1"))""")
+          println(s"""assertEquals("decomposed should match", ("1", unit), $summon[Composition[String, Unit]].decompose("1"))""")
+        }
       }
 
       println()
 
       enter("""@Test def `unit+scalar`(): Unit = {""")("}") {
         println("""assertEquals("composed should match", "2", TupleComposition.compose(unit, "2"))""")
+        if (scala3) {
+          println(s"""assertEquals("decomposed should match", (unit, "2"), $summon[Decompose[Unit, String]].decompose("2"))""")
+          println(s"""assertEquals("decomposed should match", (unit, "2"), $summon[Composition[Unit, String]].decompose("2"))""")
+        }
       }
 
       println()
 
+      def tupleElements(size: Int, offset: Int): String = {
+        if (size == 1) {
+          s"${offset + 1}"
+        } else {
+          s"${(offset + 1 to offset + size).mkString(", ")}"
+        }
+      }
+
       def tupleValue(size: Int, offset: Int): String = {
         if (size == 1) {
-          s"Tuple1(${offset + 1})"
+          s"Tuple1(${tupleElements(size, offset)})"
         } else {
-          s"(${(offset + 1 to offset + size).mkString(", ")})"
+          s"(${tupleElements(size, offset)})"
+        }
+      }
+
+      def tupleType(size: Int): String = {
+        if (size == 1) {
+          s"Tuple1[Int]"
+        } else {
+          s"(${(1 to size).map(_ => "Int").mkString(", ")})"
         }
       }
 
@@ -55,7 +89,22 @@ class TupleCompositionTestGenerator(sourceManaged: File, to: Int, testConcats: B
         enter(s"""@Test def `${size1}-tuple+Unit`(): Unit = {""")("}") {
           println(s"""val tuple = ${tupleValue(size1, 100)}""")
           println(s"""assertEquals("composed should match", tuple, TupleComposition.compose(tuple, (): Unit))""")
+          if (scala3) {
+            println(s"""assertEquals("decomposed should match", (tuple, unit), $summon[Decompose[${tupleType(size1)}, Unit]].decompose(tuple))""")
+            println(s"""assertEquals("decomposed should match", (tuple, unit), $summon[Composition[${tupleType(size1)}, Unit]].decompose(tuple))""")
+          }
+        }
+        println()
+      }
+
+      for (size1 <- 1 until to) {
+        enter(s"""@Test def `${size1}-Unit+tuple`(): Unit = {""")("}") {
+          println(s"""val tuple = ${tupleValue(size1, 100)}""")
           println(s"""assertEquals("composed should match", tuple, TupleComposition.compose((): Unit, tuple))""")
+          if (scala3) {
+            println(s"""assertEquals("decomposed should match", (unit, tuple), $summon[Decompose[Unit, ${tupleType(size1)}]].decompose(tuple))""")
+            println(s"""assertEquals("decomposed should match", (unit, tuple), $summon[Composition[Unit, ${tupleType(size1)}]].decompose(tuple))""")
+          }
         }
         println()
       }
@@ -63,8 +112,12 @@ class TupleCompositionTestGenerator(sourceManaged: File, to: Int, testConcats: B
       for (size1 <- 1 until to) {
         enter(s"""@Test def `${size1}-tuple+scalar`(): Unit = {""")("}") {
           println(s"""val tuple = ${tupleValue(size1, 100)}""")
-          println(s"""val expected = (${(101 until 101 + size1).mkString(", ")}, 201)""")
+          println(s"""val expected = (${tupleElements(size1, 100)}, 201)""")
           println(s"""assertEquals("composed should match", expected, TupleComposition.compose(tuple, 201))""")
+          if (scala3) {
+            println(s"""assertEquals("decomposed should match", (tuple, 201), $summon[Decompose[${tupleType(size1)}, Int]].decompose(expected))""")
+            println(s"""assertEquals("decomposed should match", (tuple, 201), $summon[Composition[${tupleType(size1)}, Int]].decompose(expected))""")
+          }
         }
         println()
       }
@@ -73,8 +126,12 @@ class TupleCompositionTestGenerator(sourceManaged: File, to: Int, testConcats: B
         for (size1 <- 1 until to) {
           enter(s"""@Test def `scalar+${size1}-tuple`(): Unit = {""")("}") {
             println(s"""val tuple = ${tupleValue(size1, 100)}""")
-            println(s"""val expected = (201, ${(101 until 101 + size1).mkString(", ")})""")
+            println(s"""val expected = (201, ${tupleElements(size1, 100)})""")
             println(s"""assertEquals("composed should match", expected, TupleComposition.compose(201, tuple))""")
+            if (scala3) {
+              println(s"""assertEquals("decomposed should match", (201, tuple), $summon[Decompose[Int, ${tupleType(size1)}]].decompose(expected))""")
+              println(s"""assertEquals("decomposed should match", (201, tuple), $summon[Composition[Int, ${tupleType(size1)}]].decompose(expected))""")
+            }
           }
           println()
         }
@@ -86,8 +143,12 @@ class TupleCompositionTestGenerator(sourceManaged: File, to: Int, testConcats: B
             enter(s"""@Test def `${size1}-tuple+${size2}-tuple`(): Unit = {""".stripMargin)("}") {
               println(s"""val tuple1 = ${tupleValue(size1, 100)}""")
               println(s"""val tuple2 = ${tupleValue(size2, 200)}""")
-              println(s"""val expected = (${((101 until 101 + size1) ++ (201 until 201 + size2)).mkString(", ")})""")
+              println(s"""val expected = (${tupleElements(size1, 100)}, ${tupleElements(size2, 200)})""")
               println(s"""assertEquals("composed should match", expected, TupleComposition.compose(tuple1, tuple2))""")
+              if (scala3) {
+                println(s"""assertEquals("decomposed should match", (tuple1, tuple2), $summon[Decompose[${tupleType(size1)}, ${tupleType(size2)}]].decompose(expected))""")
+                println(s"""assertEquals("decomposed should match", (tuple1, tuple2), $summon[Composition[${tupleType(size1)}, ${tupleType(size2)}]].decompose(expected))""")
+              }
             }
             println()
           }
diff --git a/project/build.properties b/project/build.properties
index 8b9a0b0..c9aaa51 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=1.8.0
+sbt.version=1.12.4
diff --git a/project/plugins.sbt b/project/plugins.sbt
index bc3a484..ee60db8 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,23 +1,17 @@
 logLevel := Level.Warn
 
-val scalajsVersion = scala.sys.env.getOrElse("SCALAJS_VERSION", "1.9.0")
+val scalajsVersion = scala.sys.env.getOrElse("SCALAJS_VERSION", "1.20.2")
 
 addSbtPlugin("org.scala-js" % "sbt-scalajs" % scalajsVersion)
 
 addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.2.0")
 
-addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.0")
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.6")
 
-addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.2.0")
+addSbtPlugin("com.github.sbt" % "sbt-github-actions" % "0.29.0")
 
-addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.15")
+addSbtPlugin("com.github.sbt" % "sbt-ci-release" % "1.11.2")
 
-addSbtPlugin("com.codecommit" % "sbt-github-actions" % "0.14.2")
+addSbtPlugin("org.typelevel" % "sbt-tpolecat" % "0.5.3")
 
-addSbtPlugin("com.github.sbt" % "sbt-ci-release" % "1.5.11")
-
-//addSbtPlugin("io.github.davidgregory084" % "sbt-tpolecat" % "0.4.1")
-
-addSbtPlugin("ch.epfl.scala" % "sbt-version-policy" % "2.1.0")
-
-addSbtPlugin("com.github.sbt" % "sbt-git" % "2.0.0")
+addSbtPlugin("ch.epfl.scala" % "sbt-version-policy" % "3.2.1")