TargetGenerated.scala

package mill.define
import scala.language.higherKinds
import mill.define.Task
import mill.util.Ctx
trait TargetGenerated {
def zip[A, B, C](a: Task[A], b: Task[B], c: Task[C]) = new Task[(A, B, C)] {
  val inputs = Seq(a, b, c)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2))
}
def zip[A, B, C, D](a: Task[A], b: Task[B], c: Task[C], d: Task[D]) = new Task[(A, B, C, D)] {
  val inputs = Seq(a, b, c, d)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3))
}
def zip[A, B, C, D, E](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E]) = new Task[(A, B, C, D, E)] {
  val inputs = Seq(a, b, c, d, e)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4))
}
def zip[A, B, C, D, E, F](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F]) = new Task[(A, B, C, D, E, F)] {
  val inputs = Seq(a, b, c, d, e, f)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5))
}
def zip[A, B, C, D, E, F, G](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G]) = new Task[(A, B, C, D, E, F, G)] {
  val inputs = Seq(a, b, c, d, e, f, g)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6))
}
def zip[A, B, C, D, E, F, G, H](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H]) = new Task[(A, B, C, D, E, F, G, H)] {
  val inputs = Seq(a, b, c, d, e, f, g, h)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7))
}
def zip[A, B, C, D, E, F, G, H, I](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I]) = new Task[(A, B, C, D, E, F, G, H, I)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8))
}
def zip[A, B, C, D, E, F, G, H, I, J](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J]) = new Task[(A, B, C, D, E, F, G, H, I, J)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9))
}
def zip[A, B, C, D, E, F, G, H, I, J, K](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K]) = new Task[(A, B, C, D, E, F, G, H, I, J, K)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N], o: Task[O]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13), args[O](14))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N], o: Task[O], p: Task[P]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13), args[O](14), args[P](15))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N], o: Task[O], p: Task[P], q: Task[Q]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13), args[O](14), args[P](15), args[Q](16))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N], o: Task[O], p: Task[P], q: Task[Q], r: Task[R]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13), args[O](14), args[P](15), args[Q](16), args[R](17))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N], o: Task[O], p: Task[P], q: Task[Q], r: Task[R], s: Task[S]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13), args[O](14), args[P](15), args[Q](16), args[R](17), args[S](18))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N], o: Task[O], p: Task[P], q: Task[Q], r: Task[R], s: Task[S], t: Task[T]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13), args[O](14), args[P](15), args[Q](16), args[R](17), args[S](18), args[T](19))
}
def zip[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](a: Task[A], b: Task[B], c: Task[C], d: Task[D], e: Task[E], f: Task[F], g: Task[G], h: Task[H], i: Task[I], j: Task[J], k: Task[K], l: Task[L], m: Task[M], n: Task[N], o: Task[O], p: Task[P], q: Task[Q], r: Task[R], s: Task[S], t: Task[T], u: Task[U]) = new Task[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)] {
  val inputs = Seq(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)
  def evaluate(args: Ctx) = (args[A](0), args[B](1), args[C](2), args[D](3), args[E](4), args[F](5), args[G](6), args[H](7), args[I](8), args[J](9), args[K](10), args[L](11), args[M](12), args[N](13), args[O](14), args[P](15), args[Q](16), args[R](17), args[S](18), args[T](19), args[U](20))
}
}