/*---------------------------------------------------------------------------
  Copyright 2012-2024, Microsoft Research, Daan Leijen.

  This is free software; you can redistribute it and/or modify it under the
  terms of the Apache License, Version 2.0. A copy of the License can be
  found in the LICENSE file at the root of this distribution.
---------------------------------------------------------------------------*/

// Standard tuple functions.
module std/core/tuplestd/core/tuple

import std/core/typesstd/core/types
import std/core/hndstd/core/hnd

// Map a function over a tuple of elements of the same type.
pub fun tuple2/mapstd/core/tuple/tuple2/map: forall<a,b,e> (t : (a, a), f : (a) -> e b) -> e (b, b)( tt: ($432, $432) : (std/core/types/tuple2: (V, V) -> Vaa: V,aa: V), ff: ($432) -> $434 $433 : aa: V -> ee: E bb: V )result: -> 538 (537, 537) : ee: E (std/core/types/tuple2: (V, V) -> Vbb: V, bb: V)
  (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)tt: ($432, $432).fststd/core/types/tuple2/fst: (tuple2 : ($432, $432)) -> $434 $432.ff: ($432) -> $434 $433, tt: ($432, $432).sndstd/core/types/tuple2/snd: (tuple2 : ($432, $432)) -> $434 $432.ff: ($432) -> $434 $433)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)

// Map a function over a triple of elements of the same type.
pub fun tuple3/mapstd/core/tuple/tuple3/map: forall<a,b,e> (t : (a, a, a), f : (a) -> e b) -> e (b, b, b)( tt: ($548, $548, $548) : (std/core/types/tuple3: (V, V, V) -> Vaa: V,aa: V,aa: V), ff: ($548) -> $550 $549 : aa: V -> ee: E bb: V )result: -> 698 (697, 697, 697) : ee: E (std/core/types/tuple3: (V, V, V) -> Vbb: V, bb: V, bb: V)
  (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)tt: ($548, $548, $548).fststd/core/types/tuple3/fst: (tuple3 : ($548, $548, $548)) -> $550 $548.ff: ($548) -> $550 $549, tt: ($548, $548, $548).sndstd/core/types/tuple3/snd: (tuple3 : ($548, $548, $548)) -> $550 $548.ff: ($548) -> $550 $549, tt: ($548, $548, $548).thdstd/core/types/tuple3/thd: (tuple3 : ($548, $548, $548)) -> $550 $548.ff: ($548) -> $550 $549)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)

// Map a function over a quadruple of elements of the same type.
pub fun tuple4/mapstd/core/tuple/tuple4/map: forall<a,b,e> (t : (a, a, a, a), f : (a) -> e b) -> e (b, b, b, b)( tt: ($708, $708, $708, $708) : (std/core/types/tuple4: (V, V, V, V) -> Vaa: V,aa: V,aa: V,aa: V), ff: ($708) -> $710 $709 : aa: V -> ee: E bb: V )result: -> 900 (899, 899, 899, 899) : ee: E (std/core/types/tuple4: (V, V, V, V) -> Vbb: V,bb: V,bb: V,bb: V)
  (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)tt: ($708, $708, $708, $708).fststd/core/types/tuple4/fst: (tuple4 : ($708, $708, $708, $708)) -> $710 $708.ff: ($708) -> $710 $709, tt: ($708, $708, $708, $708).sndstd/core/types/tuple4/snd: (tuple4 : ($708, $708, $708, $708)) -> $710 $708.ff: ($708) -> $710 $709, tt: ($708, $708, $708, $708).thdstd/core/types/tuple4/thd: (tuple4 : ($708, $708, $708, $708)) -> $710 $708.ff: ($708) -> $710 $709, tt: ($708, $708, $708, $708).field4std/core/types/tuple4/field4: (tuple4 : ($708, $708, $708, $708)) -> $710 $708.ff: ($708) -> $710 $709)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)

// Map a function over a quintuple of elements of the same type.
pub fun tuple5/mapstd/core/tuple/tuple5/map: forall<a,b,e> (t : (a, a, a, a, a), f : (a) -> e b) -> e (b, b, b, b, b)( tt: ($910, $910, $910, $910, $910) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,aa: V,aa: V,aa: V,aa: V), ff: ($910) -> $912 $911 : aa: V -> ee: E bb: V )result: -> 1135 (1134, 1134, 1134, 1134, 1134) : ee: E (std/core/types/tuple5: (V, V, V, V, V) -> Vbb: V,bb: V,bb: V,bb: V,bb: V)
  (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)tt: ($910, $910, $910, $910, $910).fststd/core/types/tuple5/fst: (tuple5 : ($910, $910, $910, $910, $910)) -> $912 $910.ff: ($910) -> $912 $911, tt: ($910, $910, $910, $910, $910).sndstd/core/types/tuple5/snd: (tuple5 : ($910, $910, $910, $910, $910)) -> $912 $910.ff: ($910) -> $912 $911, tt: ($910, $910, $910, $910, $910).thdstd/core/types/tuple5/thd: (tuple5 : ($910, $910, $910, $910, $910)) -> $912 $910.ff: ($910) -> $912 $911, tt: ($910, $910, $910, $910, $910).field4std/core/types/tuple5/field4: (tuple5 : ($910, $910, $910, $910, $910)) -> $912 $910.ff: ($910) -> $912 $911, tt: ($910, $910, $910, $910, $910).field5std/core/types/tuple5/field5: (tuple5 : ($910, $910, $910, $910, $910)) -> $912 $910.ff: ($910) -> $912 $911)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)

// Compare unit values. Useful to build composite equality for structures containing a unit (e.g. either<string, ()>)
pub inline fun unit/(==)std/core/tuple/unit/(==): (a : (), b : ()) -> bool(aa: (): (std/core/types/unit: V)std/core/types/unit: V, bb: (): (std/core/types/unit: V)std/core/types/unit: V)result: -> total bool: boolstd/core/types/bool: V
  Truestd/core/types/True: bool

// Element-wise tuple equality
pub fun tuple2/(==)std/core/tuple/tuple2/(==): forall<a,b,e> ((a, b), (a, b), @implicit/fst/(==) : (a, a) -> e bool, @implicit/snd/(==) : (b, b) -> e bool) -> e bool( (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)x1x1: $1149,y1y1: $1150)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)x2x2: $1149,y2y2: $1150)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), (@implicit/fst/==)?fst/(==): ($1149, $1149) -> $1151 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1150, $1150) -> $1151 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V )result: -> 1273 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1149==?fst/(==): ($1149, $1149) -> $1151 boolx2x2: $1149) &&std/core/types/(&&): (x : bool, y : bool) -> $1151 bool (y1y1: $1150==?snd/(==): ($1150, $1150) -> $1151 booly2y2: $1150)

// Element-wise triple equality
pub fun tuple3/(==)std/core/tuple/tuple3/(==): forall<a,b,c,e> ((a, b, c), (a, b, c), @implicit/fst/(==) : (a, a) -> e bool, @implicit/snd/(==) : (b, b) -> e bool, @implicit/thd/(==) : (c, c) -> e bool) -> e bool( (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)x1x1: $1274,y1y1: $1275,z1z1: $1276)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c) : (std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)x2x2: $1274,y2y2: $1275,z2z2: $1276)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c) : (std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V), (@implicit/fst/==)?fst/(==): ($1274, $1274) -> $1277 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1275, $1275) -> $1277 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V, (@implicit/thd/==)?thd/(==): ($1276, $1276) -> $1277 bool : (cc: V,cc: V) -> ee: E boolstd/core/types/bool: V )result: -> 1455 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1274==?fst/(==): ($1274, $1274) -> $1277 boolx2x2: $1274) &&std/core/types/(&&): (x : bool, y : bool) -> $1277 bool (y1y1: $1275==?snd/(==): ($1275, $1275) -> $1277 booly2y2: $1275) &&std/core/types/(&&): (x : bool, y : bool) -> $1277 bool (z1z1: $1276==?thd/(==): ($1276, $1276) -> $1277 boolz2z2: $1276)

// Element-wise quadruple equality
pub fun tuple4/(==)std/core/tuple/tuple4/(==): forall<a,b,c,d,e> ((a, b, c, d), (a, b, c, d), @implicit/fst/(==) : (a, a) -> e bool, @implicit/snd/(==) : (b, b) -> e bool, @implicit/thd/(==) : (c, c) -> e bool, @implicit/field4/(==) : (d, d) -> e bool) -> e bool( (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)x1x1: $1456,y1y1: $1457,z1z1: $1458,w1w1: $1459)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d) : (std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)x2x2: $1456,y2y2: $1457,z2z2: $1458,w2w2: $1459)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d) : (std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V), 
                      (@implicit/fst/==)?fst/(==): ($1456, $1456) -> $1460 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1457, $1457) -> $1460 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V, 
                      (@implicit/thd/==)?thd/(==): ($1458, $1458) -> $1460 bool : (cc: V,cc: V) -> ee: E boolstd/core/types/bool: V, (@implicit/field4/==)?field4/(==): ($1459, $1459) -> $1460 bool : (dd: V,dd: V) -> ee: E boolstd/core/types/bool: V )result: -> 1694 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1456==?fst/(==): ($1456, $1456) -> $1460 boolx2x2: $1456) &&std/core/types/(&&): (x : bool, y : bool) -> $1460 bool (y1y1: $1457==?snd/(==): ($1457, $1457) -> $1460 booly2y2: $1457) &&std/core/types/(&&): (x : bool, y : bool) -> $1460 bool (z1z1: $1458==?thd/(==): ($1458, $1458) -> $1460 boolz2z2: $1458) &&std/core/types/(&&): (x : bool, y : bool) -> $1460 bool (w1w1: $1459==?field4/(==): ($1459, $1459) -> $1460 boolw2w2: $1459)

// Element-wise quintuple equality
pub fun tuple5/(==)std/core/tuple/tuple5/(==): forall<a,b,c,d,e,a1> ((a, b, c, d, a1), (a, b, c, d, a1), @implicit/fst/(==) : (a, a) -> e bool, @implicit/snd/(==) : (b, b) -> e bool, @implicit/thd/(==) : (c, c) -> e bool, @implicit/field4/(==) : (d, d) -> e bool, @implicit/field5/(==) : (a1, a1) -> e bool) -> e bool( (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)x1x1: $1695,y1y1: $1696,z1z1: $1697,w1w1: $1698,v1v1: $1700)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V,ff: V), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)x2x2: $1695,y2y2: $1696,z2z2: $1697,w2w2: $1698,v2v2: $1700)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V,ff: V), 
                        (@implicit/fst/==)?fst/(==): ($1695, $1695) -> $1699 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1696, $1696) -> $1699 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V, (@implicit/thd/==)?thd/(==): ($1697, $1697) -> $1699 bool : (cc: V,cc: V) -> ee: E boolstd/core/types/bool: V, 
                        (@implicit/field4/==)?field4/(==): ($1698, $1698) -> $1699 bool : (dd: V,dd: V) -> ee: E boolstd/core/types/bool: V, (@implicit/field5/==)?field5/(==): ($1700, $1700) -> $1699 bool : (ff: V,ff: V) -> ee: E boolstd/core/types/bool: V )result: -> 1989 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1695==?fst/(==): ($1695, $1695) -> $1699 boolx2x2: $1695) &&std/core/types/(&&): (x : bool, y : bool) -> $1699 bool (y1y1: $1696==?snd/(==): ($1696, $1696) -> $1699 booly2y2: $1696) &&std/core/types/(&&): (x : bool, y : bool) -> $1699 bool (z1z1: $1697==?thd/(==): ($1697, $1697) -> $1699 boolz2z2: $1697) &&std/core/types/(&&): (x : bool, y : bool) -> $1699 bool (w1w1: $1698==?field4/(==): ($1698, $1698) -> $1699 boolw2w2: $1698) &&std/core/types/(&&): (x : bool, y : bool) -> $1699 bool (v1v1: $1700==?field5/(==): ($1700, $1700) -> $1699 boolv2v2: $1700)

// Order on unit
pub inline fun unit/cmpstd/core/tuple/unit/cmp: (a : (), b : ()) -> order( aa: (): (std/core/types/unit: V)std/core/types/unit: V, bb: (): (std/core/types/unit: V)std/core/types/unit: V )result: -> total order : orderstd/core/types/order: V
  Eqstd/core/types/Eq: order

// Order on tuples
pub fun tuple2/cmpstd/core/tuple/tuple2/cmp: forall<a,b,e> ((a, b), (a, b), @implicit/fst/cmp : (a, a) -> e order, @implicit/snd/cmp : (b, b) -> e order) -> e order( (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)x1x1: $2049,y1y1: $2050)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)x2x2: $2049,y2y2: $2050)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), @implicit/fst/cmp?fst/cmp: ($2049, $2049) -> $2051 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, @implicit/snd/cmp?snd/cmp: ($2050, $2050) -> $2051 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V )result: -> 2095 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2049, $2049) -> $2051 order(x1x1: $2049,x2x2: $2049)
    Eqstd/core/types/Eq: order -> snd/cmp?snd/cmp: ($2050, $2050) -> $2051 order(y1y1: $2050,y2y2: $2050)
    lglg: order -> lglg: order

// Order on triples
pub fbip fun tuple3/cmpstd/core/tuple/tuple3/cmp: forall<a,b,c,e> ((a, b, c), (a, b, c), @implicit/fst/cmp : (a, a) -> e order, @implicit/snd/cmp : (b, b) -> e order, @implicit/thd/cmp : (c, c) -> e order) -> e order( (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)x1x1: $2096,y1y1: $2097,z1z1: $2098)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c) : (std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)x2x2: $2096,y2y2: $2097,z2z2: $2098)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c) : (std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V), ^@implicit/fst/cmp?fst/cmp: ($2096, $2096) -> $2099 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, ^@implicit/snd/cmp?snd/cmp: ($2097, $2097) -> $2099 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V, ^@implicit/thd/cmp?thd/cmp: ($2098, $2098) -> $2099 order : (cc: V,cc: V) -> ee: E orderstd/core/types/order: V )result: -> 2160 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2096, $2096) -> $2099 order(x1x1: $2096,x2x2: $2096)
    Eqstd/core/types/Eq: order -> match snd/cmp?snd/cmp: ($2097, $2097) -> $2099 order(y1y1: $2097,y2y2: $2097)
            Eqstd/core/types/Eq: order -> thd/cmp?thd/cmp: ($2098, $2098) -> $2099 order(z1z1: $2098,z2z2: $2098)
            lglg: order -> lglg: order
    lglg: order -> lglg: order

// Order on quadruples
pub fbip fun tuple4/cmpstd/core/tuple/tuple4/cmp: forall<a,b,c,d,e> ((a, b, c, d), (a, b, c, d), @implicit/fst/cmp : (a, a) -> e order, @implicit/snd/cmp : (b, b) -> e order, @implicit/thd/cmp : (c, c) -> e order, @implicit/field4/cmp : (d, d) -> e order) -> e order( (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)x1x1: $2161,y1y1: $2162,z1z1: $2163,w1w1: $2164)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d) : (std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)x2x2: $2161,y2y2: $2162,z2z2: $2163,w2w2: $2164)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d) : (std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V), 
                            ^@implicit/fst/cmp?fst/cmp: ($2161, $2161) -> $2165 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, ^@implicit/snd/cmp?snd/cmp: ($2162, $2162) -> $2165 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V, 
                            ^@implicit/thd/cmp?thd/cmp: ($2163, $2163) -> $2165 order : (cc: V,cc: V) -> ee: E orderstd/core/types/order: V, ^@implicit/field4/cmp?field4/cmp: ($2164, $2164) -> $2165 order : (dd: V,dd: V) -> ee: E orderstd/core/types/order: V )result: -> 2243 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2161, $2161) -> $2165 order(x1x1: $2161,x2x2: $2161)
    Eqstd/core/types/Eq: order -> match snd/cmp?snd/cmp: ($2162, $2162) -> $2165 order(y1y1: $2162,y2y2: $2162)
            Eqstd/core/types/Eq: order -> match thd/cmp?thd/cmp: ($2163, $2163) -> $2165 order(z1z1: $2163,z2z2: $2163)
                    Eqstd/core/types/Eq: order -> field4/cmp?field4/cmp: ($2164, $2164) -> $2165 order(w1w1: $2164,w2w2: $2164)
                    lglg: order -> lglg: order
            lglg: order -> lglg: order
    lglg: order -> lglg: order

// Order on quintuples
pub fbip fun tuple5/cmpstd/core/tuple/tuple5/cmp: forall<a,b,c,d,e,a1> ((a, b, c, d, a1), (a, b, c, d, a1), @implicit/fst/cmp : (a, a) -> e order, @implicit/snd/cmp : (b, b) -> e order, @implicit/thd/cmp : (c, c) -> e order, @implicit/field4/cmp : (d, d) -> e order, @implicit/field5/cmp : (a1, a1) -> e order) -> e order( (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)x1x1: $2244,y1y1: $2245,z1z1: $2246,w1w1: $2247,v1v1: $2249)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V,ff: V), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)x2x2: $2244,y2y2: $2245,z2z2: $2246,w2w2: $2247,v2v2: $2249)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V,ff: V), 
                            ^@implicit/fst/cmp?fst/cmp: ($2244, $2244) -> $2248 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, ^@implicit/snd/cmp?snd/cmp: ($2245, $2245) -> $2248 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V, ^@implicit/thd/cmp?thd/cmp: ($2246, $2246) -> $2248 order : (cc: V,cc: V) -> ee: E orderstd/core/types/order: V, 
                            ^@implicit/field4/cmp?field4/cmp: ($2247, $2247) -> $2248 order : (dd: V,dd: V) -> ee: E orderstd/core/types/order: V, ^@implicit/field5/cmp?field5/cmp: ($2249, $2249) -> $2248 order : (ff: V,ff: V) -> ee: E orderstd/core/types/order: V )result: -> 2343 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2244, $2244) -> $2248 order(x1x1: $2244,x2x2: $2244)
    Eqstd/core/types/Eq: order -> match snd/cmp?snd/cmp: ($2245, $2245) -> $2248 order(y1y1: $2245,y2y2: $2245)
            Eqstd/core/types/Eq: order -> match thd/cmp?thd/cmp: ($2246, $2246) -> $2248 order(z1z1: $2246,z2z2: $2246)
                    Eqstd/core/types/Eq: order -> match field4/cmp?field4/cmp: ($2247, $2247) -> $2248 order(w1w1: $2247,w2w2: $2247)
                            Eqstd/core/types/Eq: order -> field5/cmp?field5/cmp: ($2249, $2249) -> $2248 order(v1v1: $2249,v2v2: $2249)
                            lglg: order -> lglg: order
                    lglg: order -> lglg: order
            lglg: order -> lglg: order
    lglg: order -> lglg: order

// fip ordering of unit values
pub inline fip fun unit/order2std/core/tuple/unit/order2: (a : (), b : ()) -> order2<()>( aa: (): (std/core/types/unit: V)std/core/types/unit: V, bb: (): (std/core/types/unit: V)std/core/types/unit: V )result: -> total order2<()> : order2std/core/types/order2: V -> V<(std/core/types/unit: V)std/core/types/unit: V>
  Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(aa: ())

// order2 of tuple2 values
pub fun tuple2/order2std/core/tuple/tuple2/order2: forall<a,b,e> ((a, b), (a, b), @implicit/a/order2 : (a, a) -> e order2<a>, @implicit/b/order2 : (b, b) -> e order2<b>) -> e order2<(a, b)>( (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)x1x1: $2410, x2x2: $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b): (std/core/types/tuple2: (V, V) -> Vaa: V, bb: V), (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)y1y1: $2410, y2y2: $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b): (std/core/types/tuple2: (V, V) -> Vaa: V, bb: V), 
                      ^@implicit/a/order2?a/order2: ($2410, $2410) -> $2412 order2<$2410>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($2411, $2411) -> $2412 order2<$2411>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V> )result: -> 2695 order2<(2693, 2694)>: ee: E order2std/core/types/order2: V -> V<(std/core/types/tuple2: (V, V) -> Vaa: V,bb: V)>
  match order2?a/order2: ($2410, $2410) -> $2412 order2<$2410>(x1x1: $2410, y1y1: $2410)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $2410) -> match order2?b/order2: ($2411, $2411) -> $2412 order2<$2411>(x2x2: $2411, y2y2: $2411)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $2411) -> Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)z1z1: $2410, z2z2: $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)) 
      Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x2'x2': $2411, y2'y2': $2411) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)z1z1: $2410, x2'x2': $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b), (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)z1z1: $2410, y2'y2': $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b))
      Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y2'y2': $2411, x2'x2': $2411) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)z1z1: $2410, y2'y2': $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b), (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)z1z1: $2410, x2'x2': $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b))
    Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x1'x1': $2410, y1'y1': $2410) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)x1'x1': $2410, x2x2: $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b), (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)y1'y1': $2410, y2y2: $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b))
    Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y1'y1': $2410, x1'x1': $2410) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)y1'y1': $2410, y2y2: $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b), (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)x1'x1': $2410, x2x2: $2411)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b))

// order2 of tuple3 values
pub fun tuple3/order2std/core/tuple/tuple3/order2: forall<a,b,c,e> ((a, b, c), (a, b, c), @implicit/a/order2 : (a, a) -> e order2<a>, @implicit/b/order2 : (b, b) -> e order2<b>, @implicit/c/order2 : (c, c) -> e order2<c>) -> e order2<(a, b, c)>( (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)x1x1: $2696, x2x2: $2697, x3x3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c): (std/core/types/tuple3: (V, V, V) -> Vaa: V, bb: V, cc: V), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)y1y1: $2696, y2y2: $2697, y3y3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c): (std/core/types/tuple3: (V, V, V) -> Vaa: V, bb: V, cc: V), 
                      ^@implicit/a/order2?a/order2: ($2696, $2696) -> $2699 order2<$2696>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($2697, $2697) -> $2699 order2<$2697>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V>, 
                      ^@implicit/c/order2?c/order2: ($2698, $2698) -> $2699 order2<$2698>: (cc: V, cc: V) -> ee: E order2std/core/types/order2: V -> V<cc: V> )result: -> 3159 order2<(3156, 3157, 3158)>: ee: E order2std/core/types/order2: V -> V<(std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V)>
  match order2?a/order2: ($2696, $2696) -> $2699 order2<$2696>(x1x1: $2696, y1y1: $2696)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $2696) -> match order2?b/order2: ($2697, $2697) -> $2699 order2<$2697>(x2x2: $2697, y2y2: $2697)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $2697) -> match order2?c/order2: ($2698, $2698) -> $2699 order2<$2698>(x3x3: $2698, y3y3: $2698)
        Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z3z3: $2698) -> Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, z2z2: $2697, z3z3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c))
        Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x3'x3': $2698, y3'y3': $2698) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, z2z2: $2697, x3'x3': $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, z2z2: $2697, y3'y3': $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c))
        Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y3'y3': $2698, x3'x3': $2698) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, z2z2: $2697, y3'y3': $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, z2z2: $2697, x3'x3': $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c))
      Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x2'x2': $2697, y2'y2': $2697) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, x2'x2': $2697, x3x3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, y2'y2': $2697, y3y3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c))
      Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y2'y2': $2697, x2'x2': $2697) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, y2'y2': $2697, y3y3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)z1z1: $2696, x2'x2': $2697, x3x3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c))
    Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x1'x1': $2696, y1'y1': $2696) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)x1'x1': $2696, x2x2: $2697, x3x3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)y1'y1': $2696, y2y2: $2697, y3y3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c))
    Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y1'y1': $2696, x1'x1': $2696) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)y1'y1': $2696, y2y2: $2697, y3y3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c), (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)x1'x1': $2696, x2x2: $2697, x3x3: $2698)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c))

// order2 of tuple4 values
pub fun tuple4/order2std/core/tuple/tuple4/order2: forall<a,b,c,d,e> ((a, b, c, d), (a, b, c, d), @implicit/a/order2 : (a, a) -> e order2<a>, @implicit/b/order2 : (b, b) -> e order2<b>, @implicit/c/order2 : (c, c) -> e order2<c>, @implicit/field4/order2 : (d, d) -> e order2<d>) -> e order2<(a, b, c, d)>( (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)x1x1: $3160, x2x2: $3161, x3x3: $3162, x4x4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d): (std/core/types/tuple4: (V, V, V, V) -> Vaa: V, bb: V, cc: V, dd: V), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)y1y1: $3160, y2y2: $3161, y3y3: $3162, y4y4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d): (std/core/types/tuple4: (V, V, V, V) -> Vaa: V, bb: V, cc: V, dd: V), 
                      ^@implicit/a/order2?a/order2: ($3160, $3160) -> $3164 order2<$3160>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($3161, $3161) -> $3164 order2<$3161>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V>, 
                      ^@implicit/c/order2?c/order2: ($3162, $3162) -> $3164 order2<$3162>: (cc: V, cc: V) -> ee: E order2std/core/types/order2: V -> V<cc: V>, ^@implicit/field4/order2?field4/order2: ($3163, $3163) -> $3164 order2<$3163>: (dd: V, dd: V) -> ee: E order2std/core/types/order2: V -> V<dd: V> )result: -> 3833 order2<(3829, 3830, 3831, 3832)>: ee: E order2std/core/types/order2: V -> V<(std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V)>
  match order2?a/order2: ($3160, $3160) -> $3164 order2<$3160>(x1x1: $3160, y1y1: $3160)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $3160) -> match order2?b/order2: ($3161, $3161) -> $3164 order2<$3161>(x2x2: $3161, y2y2: $3161)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $3161) -> match order2?c/order2: ($3162, $3162) -> $3164 order2<$3162>(x3x3: $3162, y3y3: $3162)
        Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z3z3: $3162) -> match order2?field4/order2: ($3163, $3163) -> $3164 order2<$3163>(x4x4: $3163, y4y4: $3163)
          Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z4z4: $3163) -> Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, z3z3: $3162, z4z4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
          Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x4'x4': $3163, y4'y4': $3163) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, z3z3: $3162, x4'x4': $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, z3z3: $3162, y4'y4': $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
          Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y4'y4': $3163, x4'x4': $3163) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, z3z3: $3162, y4'y4': $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, z3z3: $3162, x4'x4': $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
        Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x3'x3': $3162, y3'y3': $3162) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, x3'x3': $3162, x4x4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, y3'y3': $3162, y4y4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
        Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y3'y3': $3162, x3'x3': $3162) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, y3'y3': $3162, y4y4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, z2z2: $3161, x3'x3': $3162, x4x4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
      Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x2'x2': $3161, y2'y2': $3161) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, x2'x2': $3161, x3x3: $3162, x4x4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, y2'y2': $3161, y3y3: $3162, y4y4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
      Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y2'y2': $3161, x2'x2': $3161) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, y2'y2': $3161, y3y3: $3162, y4y4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)z1z1: $3160, x2'x2': $3161, x3x3: $3162, x4x4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
    Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x1'x1': $3160, y1'y1': $3160) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)x1'x1': $3160, x2x2: $3161, x3x3: $3162, x4x4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)y1'y1': $3160, y2y2: $3161, y3y3: $3162, y4y4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))
    Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y1'y1': $3160, x1'x1': $3160) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)y1'y1': $3160, y2y2: $3161, y3y3: $3162, y4y4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d), (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)x1'x1': $3160, x2x2: $3161, x3x3: $3162, x4x4: $3163)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d))

// order2 of tuple5 values
pub fun tuple5/order2std/core/tuple/tuple5/order2: forall<a,b,c,d,e,a1> ((a, b, c, d, a1), (a, b, c, d, a1), @implicit/a/order2 : (a, a) -> e order2<a>, @implicit/b/order2 : (b, b) -> e order2<b>, @implicit/c/order2 : (c, c) -> e order2<c>, @implicit/field4/order2 : (d, d) -> e order2<d>, @implicit/field5/order2 : (a1, a1) -> e order2<a1>) -> e order2<(a, b, c, d, a1)>( (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)x1x1: $3834, x2x2: $3835, x3x3: $3836, x4x4: $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1): (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V, bb: V, cc: V, dd: V, ff: V), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)y1y1: $3834, y2y2: $3835, y3y3: $3836, y4y4: $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1): (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V, bb: V, cc: V, dd: V, ff: V), 
                      ^@implicit/a/order2?a/order2: ($3834, $3834) -> $3838 order2<$3834>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($3835, $3835) -> $3838 order2<$3835>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V>, ^@implicit/c/order2?c/order2: ($3836, $3836) -> $3838 order2<$3836>: (cc: V, cc: V) -> ee: E order2std/core/types/order2: V -> V<cc: V>, 
                      ^@implicit/field4/order2?field4/order2: ($3837, $3837) -> $3838 order2<$3837>: (dd: V, dd: V) -> ee: E order2std/core/types/order2: V -> V<dd: V>, ^@implicit/field5/order2?field5/order2: ($3839, $3839) -> $3838 order2<$3839>: (ff: V, ff: V) -> ee: E order2std/core/types/order2: V -> V<ff: V> )result: -> 4748 order2<(4744, 4745, 4746, 4747, 4749)>: ee: E order2std/core/types/order2: V -> V<(std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V,ff: V)>
  match order2?a/order2: ($3834, $3834) -> $3838 order2<$3834>(x1x1: $3834, y1y1: $3834)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $3834) -> match order2?b/order2: ($3835, $3835) -> $3838 order2<$3835>(x2x2: $3835, y2y2: $3835)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $3835) -> match order2?c/order2: ($3836, $3836) -> $3838 order2<$3836>(x3x3: $3836, y3y3: $3836)
        Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z3z3: $3836) -> match order2?field4/order2: ($3837, $3837) -> $3838 order2<$3837>(x4x4: $3837, y4y4: $3837)
          Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z4z4: $3837) -> match order2?field5/order2: ($3839, $3839) -> $3838 order2<$3839>(x5x5: $3839, y5y5: $3839)
            Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z5z5: $3839) -> Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, z4z4: $3837, z5z5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
            Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x5'x5': $3839, y5'y5': $3839) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, z4z4: $3837, x5'x5': $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, z4z4: $3837, y5'y5': $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
            Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y5'y5': $3839, x5'x5': $3839) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, z4z4: $3837, y5'y5': $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, z4z4: $3837, x5'x5': $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
          Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x4'x4': $3837, y4'y4': $3837) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, x4'x4': $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, y4'y4': $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
          Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y4'y4': $3837, x4'x4': $3837) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, y4'y4': $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, z3z3: $3836, x4'x4': $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
        Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x3'x3': $3836, y3'y3': $3836) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, x3'x3': $3836, x4x4: $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, y3'y3': $3836, y4y4: $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
        Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y3'y3': $3836, x3'x3': $3836) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, y3'y3': $3836, y4y4: $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, z2z2: $3835, x3'x3': $3836, x4x4: $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
      Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x2'x2': $3835, y2'y2': $3835) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, x2'x2': $3835, x3x3: $3836, x4x4: $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, y2'y2': $3835, y3y3: $3836, y4y4: $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
      Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y2'y2': $3835, x2'x2': $3835) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, y2'y2': $3835, y3y3: $3836, y4y4: $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)z1z1: $3834, x2'x2': $3835, x3x3: $3836, x4x4: $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
    Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x1'x1': $3834, y1'y1': $3834) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)x1'x1': $3834, x2x2: $3835, x3x3: $3836, x4x4: $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)y1'y1': $3834, y2y2: $3835, y3y3: $3836, y4y4: $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))
    Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y1'y1': $3834, x1'x1': $3834) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>((std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)y1'y1': $3834, y2y2: $3835, y3y3: $3836, y4y4: $3837, y5y5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1), (std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1)x1'x1': $3834, x2x2: $3835, x3x3: $3836, x4x4: $3837, x5x5: $3839)std/core/types/Tuple5: forall<a,b,c,d,a1> (fst : a, snd : b, thd : c, field4 : d, field5 : a1) -> (a, b, c, d, a1))

// Convert a unit value `()` to a string
pub inline fun unit/showstd/core/tuple/unit/show: (u : ()) -> string( uu: () : (std/core/types/unit: V)std/core/types/unit: V )result: -> total string : stringstd/core/types/string: V
  "()"literal: string
count= 2

// Show a tuple
pub fun tuple2/showstd/core/tuple/tuple2/show: forall<a,b,e> (x : (a, b), @implicit/fst/show : (a) -> e string, @implicit/snd/show : (b) -> e string) -> e string( xx: ($4808, $4809) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), @implicit/fst/show?fst/show: ($4808) -> $4810 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($4809) -> $4810 string : bb: V -> ee: E stringstd/core/types/string: V)result: -> 5011 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $4810 string xx: ($4808, $4809).fststd/core/types/tuple2/fst: (tuple2 : ($4808, $4809)) -> $4810 $4808.show?fst/show: ($4808) -> $4810 string ++std/core/types/(++): (x : string, y : string) -> $4810 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $4810 string xx: ($4808, $4809).sndstd/core/types/tuple2/snd: (tuple2 : ($4808, $4809)) -> $4810 $4809.show?snd/show: ($4809) -> $4810 string ++std/core/types/(++): (x : string, y : string) -> $4810 string ")"literal: string
count= 1

// Show a triple
pub fun tuple3/showstd/core/tuple/tuple3/show: forall<a,b,c,e> (x : (a, b, c), @implicit/fst/show : (a) -> e string, @implicit/snd/show : (b) -> e string, @implicit/thd/show : (c) -> e string) -> e string( xx: ($5012, $5013, $5014) : (std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V), @implicit/fst/show?fst/show: ($5012) -> $5015 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($5013) -> $5015 string : bb: V -> ee: E stringstd/core/types/string: V, @implicit/thd/show?thd/show: ($5014) -> $5015 string : cc: V -> ee: E stringstd/core/types/string: V)result: -> 5315 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5015 string xx: ($5012, $5013, $5014).fststd/core/types/tuple3/fst: (tuple3 : ($5012, $5013, $5014)) -> $5015 $5012.show?fst/show: ($5012) -> $5015 string ++std/core/types/(++): (x : string, y : string) -> $5015 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5015 string xx: ($5012, $5013, $5014).sndstd/core/types/tuple3/snd: (tuple3 : ($5012, $5013, $5014)) -> $5015 $5013.show?snd/show: ($5013) -> $5015 string ++std/core/types/(++): (x : string, y : string) -> $5015 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5015 string xx: ($5012, $5013, $5014).thdstd/core/types/tuple3/thd: (tuple3 : ($5012, $5013, $5014)) -> $5015 $5014.show?thd/show: ($5014) -> $5015 string ++std/core/types/(++): (x : string, y : string) -> $5015 string ")"literal: string
count= 1

// Show a quadruple
pub fun tuple4/showstd/core/tuple/tuple4/show: forall<a,b,c,d,e> (x : (a, b, c, d), @implicit/fst/show : (a) -> e string, @implicit/snd/show : (b) -> e string, @implicit/thd/show : (c) -> e string, @implicit/field4/show : (d) -> e string) -> e string( xx: ($5316, $5317, $5318, $5319) : (std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V), @implicit/fst/show?fst/show: ($5316) -> $5320 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($5317) -> $5320 string : bb: V -> ee: E stringstd/core/types/string: V, 
                                    @implicit/thd/show?thd/show: ($5318) -> $5320 string : cc: V -> ee: E stringstd/core/types/string: V, @implicit/field4/show?field4/show: ($5319) -> $5320 string : dd: V -> ee: E stringstd/core/types/string: V)result: -> 5717 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5320 string xx: ($5316, $5317, $5318, $5319).fststd/core/types/tuple4/fst: (tuple4 : ($5316, $5317, $5318, $5319)) -> $5320 $5316.show?fst/show: ($5316) -> $5320 string ++std/core/types/(++): (x : string, y : string) -> $5320 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5320 string xx: ($5316, $5317, $5318, $5319).sndstd/core/types/tuple4/snd: (tuple4 : ($5316, $5317, $5318, $5319)) -> $5320 $5317.show?snd/show: ($5317) -> $5320 string ++std/core/types/(++): (x : string, y : string) -> $5320 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5320 string xx: ($5316, $5317, $5318, $5319).thdstd/core/types/tuple4/thd: (tuple4 : ($5316, $5317, $5318, $5319)) -> $5320 $5318.show?thd/show: ($5318) -> $5320 string ++std/core/types/(++): (x : string, y : string) -> $5320 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5320 string xx: ($5316, $5317, $5318, $5319).field4std/core/types/tuple4/field4: (tuple4 : ($5316, $5317, $5318, $5319)) -> $5320 $5319.show?field4/show: ($5319) -> $5320 string ++std/core/types/(++): (x : string, y : string) -> $5320 string ")"literal: string
count= 1

// Show a quintuple
pub fun tuple5/showstd/core/tuple/tuple5/show: forall<a,b,c,d,e,a1> (x : (a, b, c, d, a1), @implicit/fst/show : (a) -> e string, @implicit/snd/show : (b) -> e string, @implicit/thd/show : (c) -> e string, @implicit/field4/show : (d) -> e string, @implicit/field5/show : (a1) -> e string) -> e string( xx: ($5718, $5719, $5720, $5721, $5723) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V,ff: V), @implicit/fst/show?fst/show: ($5718) -> $5722 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($5719) -> $5722 string : bb: V -> ee: E stringstd/core/types/string: V, @implicit/thd/show?thd/show: ($5720) -> $5722 string : cc: V -> ee: E stringstd/core/types/string: V, 
                                      @implicit/field4/show?field4/show: ($5721) -> $5722 string : dd: V -> ee: E stringstd/core/types/string: V, @implicit/field5/show?field5/show: ($5723) -> $5722 string : ff: V -> ee: E stringstd/core/types/string: V)result: -> 6207 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5722 string xx: ($5718, $5719, $5720, $5721, $5723).fststd/core/types/tuple5/fst: (tuple5 : ($5718, $5719, $5720, $5721, $5723)) -> $5722 $5718.show?fst/show: ($5718) -> $5722 string ++std/core/types/(++): (x : string, y : string) -> $5722 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5722 string xx: ($5718, $5719, $5720, $5721, $5723).sndstd/core/types/tuple5/snd: (tuple5 : ($5718, $5719, $5720, $5721, $5723)) -> $5722 $5719.show?snd/show: ($5719) -> $5722 string ++std/core/types/(++): (x : string, y : string) -> $5722 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5722 string xx: ($5718, $5719, $5720, $5721, $5723).thdstd/core/types/tuple5/thd: (tuple5 : ($5718, $5719, $5720, $5721, $5723)) -> $5722 $5720.show?thd/show: ($5720) -> $5722 string ++std/core/types/(++): (x : string, y : string) -> $5722 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5722 string xx: ($5718, $5719, $5720, $5721, $5723).field4std/core/types/tuple5/field4: (tuple5 : ($5718, $5719, $5720, $5721, $5723)) -> $5722 $5721.show?field4/show: ($5721) -> $5722 string ++std/core/types/(++): (x : string, y : string) -> $5722 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5722 string xx: ($5718, $5719, $5720, $5721, $5723).field5std/core/types/tuple5/field5: (tuple5 : ($5718, $5719, $5720, $5721, $5723)) -> $5722 $5723.show?field5/show: ($5723) -> $5722 string ++std/core/types/(++): (x : string, y : string) -> $5722 string ")"literal: string
count= 1

// _deprecated_, use `tuple2/show` instead
pub fun show-tuplestd/core/tuple/show-tuple: forall<a,b,e> (x : (a, b), showfst : (a) -> e string, showsnd : (b) -> e string) -> e string( xx: ($6263, $6264) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), showfstshowfst: ($6263) -> $6265 string : aa: V -> ee: E stringstd/core/types/string: V, showsndshowsnd: ($6264) -> $6265 string : bb: V -> ee: E stringstd/core/types/string: V )result: -> 6351 string : ee: E stringstd/core/types/string: V
  showstd/core/tuple/tuple2/show: (x : ($6263, $6264), @implicit/fst/show : ($6263) -> $6265 string, @implicit/snd/show : ($6264) -> $6265 string) -> $6265 string(xx: ($6263, $6264),@implicit/fst/show=showfstshowfst: ($6263) -> $6265 string,@implicit/snd/show=showsndshowsnd: ($6264) -> $6265 string)