• Home
• org.scalacheck
• scalacheck_sjs1_3
• 1.15.3
• source code
• GenArities.scala

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.scalacheck.GenArities.scala Maven / Gradle / Ivy

/**
Defines zip and resultOf for all arities

Auto-generated using project/codegen.scala
*/
package org.scalacheck
private[scalacheck] trait GenArities{

  // genfn //

  /** Gen creator for Function1 */
  def function1[T1,Z](g: Gen[Z])(implicit co1: Cogen[T1]): Gen[(T1) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1) => Z =
        (t1: T1) => g.pureApply(p, co1.perturb(seed0, t1))
      Gen.r[(T1) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function2 */
  def function2[T1,T2,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2]): Gen[(T1,T2) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2) => Z =
        (t1: T1,t2: T2) => g.pureApply(p, co2.perturb(co1.perturb(seed0, t1), t2))
      Gen.r[(T1,T2) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function3 */
  def function3[T1,T2,T3,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3]): Gen[(T1,T2,T3) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3) => Z =
        (t1: T1,t2: T2,t3: T3) => g.pureApply(p, co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3))
      Gen.r[(T1,T2,T3) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function4 */
  def function4[T1,T2,T3,T4,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4]): Gen[(T1,T2,T3,T4) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4) => g.pureApply(p, co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4))
      Gen.r[(T1,T2,T3,T4) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function5 */
  def function5[T1,T2,T3,T4,T5,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5]): Gen[(T1,T2,T3,T4,T5) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5) => g.pureApply(p, co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5))
      Gen.r[(T1,T2,T3,T4,T5) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function6 */
  def function6[T1,T2,T3,T4,T5,T6,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6]): Gen[(T1,T2,T3,T4,T5,T6) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6) => g.pureApply(p, co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6))
      Gen.r[(T1,T2,T3,T4,T5,T6) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function7 */
  def function7[T1,T2,T3,T4,T5,T6,T7,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7]): Gen[(T1,T2,T3,T4,T5,T6,T7) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7) => g.pureApply(p, co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function8 */
  def function8[T1,T2,T3,T4,T5,T6,T7,T8,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8) => g.pureApply(p, co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function9 */
  def function9[T1,T2,T3,T4,T5,T6,T7,T8,T9,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9) => g.pureApply(p, co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function10 */
  def function10[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10) => g.pureApply(p, co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function11 */
  def function11[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11) => g.pureApply(p, co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function12 */
  def function12[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12) => g.pureApply(p, co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function13 */
  def function13[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13) => g.pureApply(p, co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function14 */
  def function14[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14) => g.pureApply(p, co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function15 */
  def function15[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15) => g.pureApply(p, co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function16 */
  def function16[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15],co16: Cogen[T16]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15,t16: T16) => g.pureApply(p, co16.perturb(co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15), t16))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function17 */
  def function17[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15],co16: Cogen[T16],co17: Cogen[T17]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15,t16: T16,t17: T17) => g.pureApply(p, co17.perturb(co16.perturb(co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15), t16), t17))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function18 */
  def function18[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15],co16: Cogen[T16],co17: Cogen[T17],co18: Cogen[T18]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15,t16: T16,t17: T17,t18: T18) => g.pureApply(p, co18.perturb(co17.perturb(co16.perturb(co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15), t16), t17), t18))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function19 */
  def function19[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15],co16: Cogen[T16],co17: Cogen[T17],co18: Cogen[T18],co19: Cogen[T19]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15,t16: T16,t17: T17,t18: T18,t19: T19) => g.pureApply(p, co19.perturb(co18.perturb(co17.perturb(co16.perturb(co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15), t16), t17), t18), t19))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function20 */
  def function20[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15],co16: Cogen[T16],co17: Cogen[T17],co18: Cogen[T18],co19: Cogen[T19],co20: Cogen[T20]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15,t16: T16,t17: T17,t18: T18,t19: T19,t20: T20) => g.pureApply(p, co20.perturb(co19.perturb(co18.perturb(co17.perturb(co16.perturb(co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15), t16), t17), t18), t19), t20))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function21 */
  def function21[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15],co16: Cogen[T16],co17: Cogen[T17],co18: Cogen[T18],co19: Cogen[T19],co20: Cogen[T20],co21: Cogen[T21]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15,t16: T16,t17: T17,t18: T18,t19: T19,t20: T20,t21: T21) => g.pureApply(p, co21.perturb(co20.perturb(co19.perturb(co18.perturb(co17.perturb(co16.perturb(co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15), t16), t17), t18), t19), t20), t21))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }

  /** Gen creator for Function22 */
  def function22[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,Z](g: Gen[Z])(implicit co1: Cogen[T1],co2: Cogen[T2],co3: Cogen[T3],co4: Cogen[T4],co5: Cogen[T5],co6: Cogen[T6],co7: Cogen[T7],co8: Cogen[T8],co9: Cogen[T9],co10: Cogen[T10],co11: Cogen[T11],co12: Cogen[T12],co13: Cogen[T13],co14: Cogen[T14],co15: Cogen[T15],co16: Cogen[T16],co17: Cogen[T17],co18: Cogen[T18],co19: Cogen[T19],co20: Cogen[T20],co21: Cogen[T21],co22: Cogen[T22]): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) => Z] =
    Gen.gen { (p, seed0) =>
      val f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) => Z =
        (t1: T1,t2: T2,t3: T3,t4: T4,t5: T5,t6: T6,t7: T7,t8: T8,t9: T9,t10: T10,t11: T11,t12: T12,t13: T13,t14: T14,t15: T15,t16: T16,t17: T17,t18: T18,t19: T19,t20: T20,t21: T21,t22: T22) => g.pureApply(p, co22.perturb(co21.perturb(co20.perturb(co19.perturb(co18.perturb(co17.perturb(co16.perturb(co15.perturb(co14.perturb(co13.perturb(co12.perturb(co11.perturb(co10.perturb(co9.perturb(co8.perturb(co7.perturb(co6.perturb(co5.perturb(co4.perturb(co3.perturb(co2.perturb(co1.perturb(seed0, t1), t2), t3), t4), t5), t6), t7), t8), t9), t10), t11), t12), t13), t14), t15), t16), t17), t18), t19), t20), t21), t22))
      Gen.r[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) => Z](
        r = Some(f),
        sd = seed0.next
      )
    }


  // zip //

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1](
    g1:Gen[T1]
  ): Gen[(T1)] =
    g1.map { t1 => (t1) }

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2](
    g1:Gen[T1], g2:Gen[T2]
  ): Gen[(T1,T2)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2)]] { def apply(t1: T1): Gen[(T1,T2)] = g2.map { t2 => (t1, t2) } })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3]
  ): Gen[(T1,T2,T3)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3)]] { def apply(t1: T1): Gen[(T1,T2,T3)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3)]] { def apply(t2: T2): Gen[(T1,T2,T3)] = g3.map { t3 => (t1, t2, t3) } }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4]
  ): Gen[(T1,T2,T3,T4)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4)] = g4.map { t4 => (t1, t2, t3, t4) } }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5]
  ): Gen[(T1,T2,T3,T4,T5)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5)] = g5.map { t5 => (t1, t2, t3, t4, t5) } }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6]
  ): Gen[(T1,T2,T3,T4,T5,T6)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6)] = g6.map { t6 => (t1, t2, t3, t4, t5, t6) } }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7)] = g7.map { t7 => (t1, t2, t3, t4, t5, t6, t7) } }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8)] = g8.map { t8 => (t1, t2, t3, t4, t5, t6, t7, t8) } }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9)] = g9.map { t9 => (t1, t2, t3, t4, t5, t6, t7, t8, t9) } }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)] = g10.map { t10 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) } }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)] = g11.map { t11 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) } }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)] = g12.map { t12 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) } }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)] = g13.map { t13 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) } }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)] = g14.map { t14 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) } }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)] = g15.map { t15 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) } }) }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15], g16:Gen[T16]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g15.flatMap(new Function1[T15, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)]] { def apply(t15: T15): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)] = g16.map { t16 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16) } }) }) }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15], g16:Gen[T16], g17:Gen[T17]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g15.flatMap(new Function1[T15, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t15: T15): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g16.flatMap(new Function1[T16, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)]] { def apply(t16: T16): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)] = g17.map { t17 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17) } }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15], g16:Gen[T16], g17:Gen[T17], g18:Gen[T18]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g15.flatMap(new Function1[T15, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t15: T15): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g16.flatMap(new Function1[T16, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t16: T16): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g17.flatMap(new Function1[T17, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)]] { def apply(t17: T17): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)] = g18.map { t18 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18) } }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15], g16:Gen[T16], g17:Gen[T17], g18:Gen[T18], g19:Gen[T19]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g15.flatMap(new Function1[T15, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t15: T15): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g16.flatMap(new Function1[T16, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t16: T16): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g17.flatMap(new Function1[T17, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t17: T17): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g18.flatMap(new Function1[T18, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)]] { def apply(t18: T18): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)] = g19.map { t19 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19) } }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15], g16:Gen[T16], g17:Gen[T17], g18:Gen[T18], g19:Gen[T19], g20:Gen[T20]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g15.flatMap(new Function1[T15, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t15: T15): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g16.flatMap(new Function1[T16, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t16: T16): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g17.flatMap(new Function1[T17, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t17: T17): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g18.flatMap(new Function1[T18, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t18: T18): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g19.flatMap(new Function1[T19, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)]] { def apply(t19: T19): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)] = g20.map { t20 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) } }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15], g16:Gen[T16], g17:Gen[T17], g18:Gen[T18], g19:Gen[T19], g20:Gen[T20], g21:Gen[T21]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g15.flatMap(new Function1[T15, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t15: T15): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g16.flatMap(new Function1[T16, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t16: T16): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g17.flatMap(new Function1[T17, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t17: T17): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g18.flatMap(new Function1[T18, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t18: T18): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g19.flatMap(new Function1[T19, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t19: T19): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g20.flatMap(new Function1[T20, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)]] { def apply(t20: T20): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)] = g21.map { t21 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21) } }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })

  /** Combines the given generators into one generator that produces a
   *  tuple of their generated values. */
  def zip[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22](
    g1:Gen[T1], g2:Gen[T2], g3:Gen[T3], g4:Gen[T4], g5:Gen[T5], g6:Gen[T6], g7:Gen[T7], g8:Gen[T8], g9:Gen[T9], g10:Gen[T10], g11:Gen[T11], g12:Gen[T12], g13:Gen[T13], g14:Gen[T14], g15:Gen[T15], g16:Gen[T16], g17:Gen[T17], g18:Gen[T18], g19:Gen[T19], g20:Gen[T20], g21:Gen[T21], g22:Gen[T22]
  ): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] =
    g1.flatMap(new Function1[T1, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t1: T1): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g2.flatMap(new Function1[T2, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t2: T2): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g3.flatMap(new Function1[T3, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t3: T3): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g4.flatMap(new Function1[T4, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t4: T4): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g5.flatMap(new Function1[T5, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t5: T5): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g6.flatMap(new Function1[T6, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t6: T6): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g7.flatMap(new Function1[T7, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t7: T7): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g8.flatMap(new Function1[T8, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t8: T8): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g9.flatMap(new Function1[T9, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t9: T9): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g10.flatMap(new Function1[T10, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t10: T10): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g11.flatMap(new Function1[T11, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t11: T11): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g12.flatMap(new Function1[T12, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t12: T12): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g13.flatMap(new Function1[T13, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t13: T13): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g14.flatMap(new Function1[T14, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t14: T14): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g15.flatMap(new Function1[T15, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t15: T15): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g16.flatMap(new Function1[T16, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t16: T16): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g17.flatMap(new Function1[T17, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t17: T17): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g18.flatMap(new Function1[T18, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t18: T18): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g19.flatMap(new Function1[T19, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t19: T19): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g20.flatMap(new Function1[T20, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t20: T20): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g21.flatMap(new Function1[T21, Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)]] { def apply(t21: T21): Gen[(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)] = g22.map { t22 => (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22) } }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) }) })


  // resultOf //
  import Arbitrary.arbitrary
  def resultOf[T,R](f: T => R)(implicit a: Arbitrary[T]): Gen[R]

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,R]
    (f: (T1,T2) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,R]
    (f: (T1,T2,T3) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,R]
    (f: (T1,T2,T3,T4) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,R]
    (f: (T1,T2,T3,T4,T5) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,R]
    (f: (T1,T2,T3,T4,T5,T6) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,R]
    (f: (T1,T2,T3,T4,T5,T6,T7) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15], a16:Arbitrary[T16]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15,_:T16))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15], a16:Arbitrary[T16], a17:Arbitrary[T17]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15,_:T16,_:T17))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15], a16:Arbitrary[T16], a17:Arbitrary[T17], a18:Arbitrary[T18]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15,_:T16,_:T17,_:T18))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15], a16:Arbitrary[T16], a17:Arbitrary[T17], a18:Arbitrary[T18], a19:Arbitrary[T19]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15,_:T16,_:T17,_:T18,_:T19))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15], a16:Arbitrary[T16], a17:Arbitrary[T17], a18:Arbitrary[T18], a19:Arbitrary[T19], a20:Arbitrary[T20]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15,_:T16,_:T17,_:T18,_:T19,_:T20))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15], a16:Arbitrary[T16], a17:Arbitrary[T17], a18:Arbitrary[T18], a19:Arbitrary[T19], a20:Arbitrary[T20], a21:Arbitrary[T21]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15,_:T16,_:T17,_:T18,_:T19,_:T20,_:T21))
    }

  /** Takes a function and returns a generator that generates arbitrary
   *  results of that function by feeding it with arbitrarily generated input
   *  parameters. */
  def resultOf[T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,R]
    (f: (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) => R)
    (implicit
      a1:Arbitrary[T1], a2:Arbitrary[T2], a3:Arbitrary[T3], a4:Arbitrary[T4], a5:Arbitrary[T5], a6:Arbitrary[T6], a7:Arbitrary[T7], a8:Arbitrary[T8], a9:Arbitrary[T9], a10:Arbitrary[T10], a11:Arbitrary[T11], a12:Arbitrary[T12], a13:Arbitrary[T13], a14:Arbitrary[T14], a15:Arbitrary[T15], a16:Arbitrary[T16], a17:Arbitrary[T17], a18:Arbitrary[T18], a19:Arbitrary[T19], a20:Arbitrary[T20], a21:Arbitrary[T21], a22:Arbitrary[T22]
    ): Gen[R] = arbitrary[T1] flatMap {
      t => resultOf(f(t,_:T2,_:T3,_:T4,_:T5,_:T6,_:T7,_:T8,_:T9,_:T10,_:T11,_:T12,_:T13,_:T14,_:T15,_:T16,_:T17,_:T18,_:T19,_:T20,_:T21,_:T22))
    }

}