/*---------------------------------------------------------------------------
  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: -> 904 (903, 903, 903, 903) : 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: ($914, $914, $914, $914, $914) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,aa: V,aa: V,aa: V,aa: V), ff: ($914) -> $916 $915 : aa: V -> ee: E bb: V )result: -> 1139 (1138, 1138, 1138, 1138, 1138) : 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: ($914, $914, $914, $914, $914).fststd/core/types/tuple5/fst: (tuple5 : ($914, $914, $914, $914, $914)) -> $916 $914.ff: ($914) -> $916 $915, tt: ($914, $914, $914, $914, $914).sndstd/core/types/tuple5/snd: (tuple5 : ($914, $914, $914, $914, $914)) -> $916 $914.ff: ($914) -> $916 $915, tt: ($914, $914, $914, $914, $914).thdstd/core/types/tuple5/thd: (tuple5 : ($914, $914, $914, $914, $914)) -> $916 $914.ff: ($914) -> $916 $915, tt: ($914, $914, $914, $914, $914).field4std/core/types/tuple5/field4: (tuple5 : ($914, $914, $914, $914, $914)) -> $916 $914.ff: ($914) -> $916 $915, tt: ($914, $914, $914, $914, $914).field5std/core/types/tuple5/field5: (tuple5 : ($914, $914, $914, $914, $914)) -> $916 $914.ff: ($914) -> $916 $915)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: $1153,y1y1: $1154)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: $1153,y2y2: $1154)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/(==): ($1153, $1153) -> $1155 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1154, $1154) -> $1155 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V )result: -> 1277 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1153==?fst/(==): ($1153, $1153) -> $1155 boolx2x2: $1153) &&std/core/types/(&&): (x : bool, y : bool) -> $1155 bool (y1y1: $1154==?snd/(==): ($1154, $1154) -> $1155 booly2y2: $1154)

// 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: $1278,y1y1: $1279,z1z1: $1280)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: $1278,y2y2: $1279,z2z2: $1280)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/(==): ($1278, $1278) -> $1281 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1279, $1279) -> $1281 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V, (@implicit/thd/==)?thd/(==): ($1280, $1280) -> $1281 bool : (cc: V,cc: V) -> ee: E boolstd/core/types/bool: V )result: -> 1459 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1278==?fst/(==): ($1278, $1278) -> $1281 boolx2x2: $1278) &&std/core/types/(&&): (x : bool, y : bool) -> $1281 bool (y1y1: $1279==?snd/(==): ($1279, $1279) -> $1281 booly2y2: $1279) &&std/core/types/(&&): (x : bool, y : bool) -> $1281 bool (z1z1: $1280==?thd/(==): ($1280, $1280) -> $1281 boolz2z2: $1280)

// 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: $1460,y1y1: $1461,z1z1: $1462,w1w1: $1463)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: $1460,y2y2: $1461,z2z2: $1462,w2w2: $1463)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/(==): ($1460, $1460) -> $1464 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1461, $1461) -> $1464 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V, 
                      (@implicit/thd/==)?thd/(==): ($1462, $1462) -> $1464 bool : (cc: V,cc: V) -> ee: E boolstd/core/types/bool: V, (@implicit/field4/==)?field4/(==): ($1463, $1463) -> $1464 bool : (dd: V,dd: V) -> ee: E boolstd/core/types/bool: V )result: -> 1698 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1460==?fst/(==): ($1460, $1460) -> $1464 boolx2x2: $1460) &&std/core/types/(&&): (x : bool, y : bool) -> $1464 bool (y1y1: $1461==?snd/(==): ($1461, $1461) -> $1464 booly2y2: $1461) &&std/core/types/(&&): (x : bool, y : bool) -> $1464 bool (z1z1: $1462==?thd/(==): ($1462, $1462) -> $1464 boolz2z2: $1462) &&std/core/types/(&&): (x : bool, y : bool) -> $1464 bool (w1w1: $1463==?field4/(==): ($1463, $1463) -> $1464 boolw2w2: $1463)

// 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: $1699,y1y1: $1700,z1z1: $1701,w1w1: $1702,v1v1: $1704)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: $1699,y2y2: $1700,z2z2: $1701,w2w2: $1702,v2v2: $1704)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/(==): ($1699, $1699) -> $1703 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V, (@implicit/snd/==)?snd/(==): ($1700, $1700) -> $1703 bool : (bb: V,bb: V) -> ee: E boolstd/core/types/bool: V, (@implicit/thd/==)?thd/(==): ($1701, $1701) -> $1703 bool : (cc: V,cc: V) -> ee: E boolstd/core/types/bool: V, 
                        (@implicit/field4/==)?field4/(==): ($1702, $1702) -> $1703 bool : (dd: V,dd: V) -> ee: E boolstd/core/types/bool: V, (@implicit/field5/==)?field5/(==): ($1704, $1704) -> $1703 bool : (ff: V,ff: V) -> ee: E boolstd/core/types/bool: V )result: -> 1993 bool : ee: E boolstd/core/types/bool: V
  (x1x1: $1699==?fst/(==): ($1699, $1699) -> $1703 boolx2x2: $1699) &&std/core/types/(&&): (x : bool, y : bool) -> $1703 bool (y1y1: $1700==?snd/(==): ($1700, $1700) -> $1703 booly2y2: $1700) &&std/core/types/(&&): (x : bool, y : bool) -> $1703 bool (z1z1: $1701==?thd/(==): ($1701, $1701) -> $1703 boolz2z2: $1701) &&std/core/types/(&&): (x : bool, y : bool) -> $1703 bool (w1w1: $1702==?field4/(==): ($1702, $1702) -> $1703 boolw2w2: $1702) &&std/core/types/(&&): (x : bool, y : bool) -> $1703 bool (v1v1: $1704==?field5/(==): ($1704, $1704) -> $1703 boolv2v2: $1704)

// 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: $2053,y1y1: $2054)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: $2053,y2y2: $2054)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: ($2053, $2053) -> $2055 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, @implicit/snd/cmp?snd/cmp: ($2054, $2054) -> $2055 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V )result: -> 2099 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2053, $2053) -> $2055 order(x1x1: $2053,x2x2: $2053)
    Eqstd/core/types/Eq: order -> snd/cmp?snd/cmp: ($2054, $2054) -> $2055 order(y1y1: $2054,y2y2: $2054)
    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: $2100,y1y1: $2101,z1z1: $2102)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: $2100,y2y2: $2101,z2z2: $2102)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: ($2100, $2100) -> $2103 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, ^@implicit/snd/cmp?snd/cmp: ($2101, $2101) -> $2103 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V, ^@implicit/thd/cmp?thd/cmp: ($2102, $2102) -> $2103 order : (cc: V,cc: V) -> ee: E orderstd/core/types/order: V )result: -> 2164 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2100, $2100) -> $2103 order(x1x1: $2100,x2x2: $2100)
    Eqstd/core/types/Eq: order -> match snd/cmp?snd/cmp: ($2101, $2101) -> $2103 order(y1y1: $2101,y2y2: $2101)
            Eqstd/core/types/Eq: order -> thd/cmp?thd/cmp: ($2102, $2102) -> $2103 order(z1z1: $2102,z2z2: $2102)
            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: $2165,y1y1: $2166,z1z1: $2167,w1w1: $2168)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: $2165,y2y2: $2166,z2z2: $2167,w2w2: $2168)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: ($2165, $2165) -> $2169 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, ^@implicit/snd/cmp?snd/cmp: ($2166, $2166) -> $2169 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V, 
                            ^@implicit/thd/cmp?thd/cmp: ($2167, $2167) -> $2169 order : (cc: V,cc: V) -> ee: E orderstd/core/types/order: V, ^@implicit/field4/cmp?field4/cmp: ($2168, $2168) -> $2169 order : (dd: V,dd: V) -> ee: E orderstd/core/types/order: V )result: -> 2247 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2165, $2165) -> $2169 order(x1x1: $2165,x2x2: $2165)
    Eqstd/core/types/Eq: order -> match snd/cmp?snd/cmp: ($2166, $2166) -> $2169 order(y1y1: $2166,y2y2: $2166)
            Eqstd/core/types/Eq: order -> match thd/cmp?thd/cmp: ($2167, $2167) -> $2169 order(z1z1: $2167,z2z2: $2167)
                    Eqstd/core/types/Eq: order -> field4/cmp?field4/cmp: ($2168, $2168) -> $2169 order(w1w1: $2168,w2w2: $2168)
                    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: $2248,y1y1: $2249,z1z1: $2250,w1w1: $2251,v1v1: $2253)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: $2248,y2y2: $2249,z2z2: $2250,w2w2: $2251,v2v2: $2253)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: ($2248, $2248) -> $2252 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V, ^@implicit/snd/cmp?snd/cmp: ($2249, $2249) -> $2252 order : (bb: V,bb: V) -> ee: E orderstd/core/types/order: V, ^@implicit/thd/cmp?thd/cmp: ($2250, $2250) -> $2252 order : (cc: V,cc: V) -> ee: E orderstd/core/types/order: V, 
                            ^@implicit/field4/cmp?field4/cmp: ($2251, $2251) -> $2252 order : (dd: V,dd: V) -> ee: E orderstd/core/types/order: V, ^@implicit/field5/cmp?field5/cmp: ($2253, $2253) -> $2252 order : (ff: V,ff: V) -> ee: E orderstd/core/types/order: V )result: -> 2347 order : ee: E orderstd/core/types/order: V
  match fst/cmp?fst/cmp: ($2248, $2248) -> $2252 order(x1x1: $2248,x2x2: $2248)
    Eqstd/core/types/Eq: order -> match snd/cmp?snd/cmp: ($2249, $2249) -> $2252 order(y1y1: $2249,y2y2: $2249)
            Eqstd/core/types/Eq: order -> match thd/cmp?thd/cmp: ($2250, $2250) -> $2252 order(z1z1: $2250,z2z2: $2250)
                    Eqstd/core/types/Eq: order -> match field4/cmp?field4/cmp: ($2251, $2251) -> $2252 order(w1w1: $2251,w2w2: $2251)
                            Eqstd/core/types/Eq: order -> field5/cmp?field5/cmp: ($2253, $2253) -> $2252 order(v1v1: $2253,v2v2: $2253)
                            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: $2414, x2x2: $2415)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: $2414, y2y2: $2415)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: ($2414, $2414) -> $2416 order2<$2414>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($2415, $2415) -> $2416 order2<$2415>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V> )result: -> 2699 order2<(2697, 2698)>: ee: E order2std/core/types/order2: V -> V<(std/core/types/tuple2: (V, V) -> Vaa: V,bb: V)>
  match order2?a/order2: ($2414, $2414) -> $2416 order2<$2414>(x1x1: $2414, y1y1: $2414)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $2414) -> match order2?b/order2: ($2415, $2415) -> $2416 order2<$2415>(x2x2: $2415, y2y2: $2415)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $2415) -> Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)z1z1: $2414, z2z2: $2415)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': $2415, y2'y2': $2415) -> 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: $2414, x2'x2': $2415)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: $2414, y2'y2': $2415)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': $2415, x2'x2': $2415) -> 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: $2414, y2'y2': $2415)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: $2414, x2'x2': $2415)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': $2414, y1'y1': $2414) -> 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': $2414, x2x2: $2415)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': $2414, y2y2: $2415)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': $2414, x1'x1': $2414) -> 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': $2414, y2y2: $2415)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': $2414, x2x2: $2415)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: $2700, x2x2: $2701, x3x3: $2702)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: $2700, y2y2: $2701, y3y3: $2702)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: ($2700, $2700) -> $2703 order2<$2700>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($2701, $2701) -> $2703 order2<$2701>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V>, 
                      ^@implicit/c/order2?c/order2: ($2702, $2702) -> $2703 order2<$2702>: (cc: V, cc: V) -> ee: E order2std/core/types/order2: V -> V<cc: V> )result: -> 3163 order2<(3160, 3161, 3162)>: 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: ($2700, $2700) -> $2703 order2<$2700>(x1x1: $2700, y1y1: $2700)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $2700) -> match order2?b/order2: ($2701, $2701) -> $2703 order2<$2701>(x2x2: $2701, y2y2: $2701)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $2701) -> match order2?c/order2: ($2702, $2702) -> $2703 order2<$2702>(x3x3: $2702, y3y3: $2702)
        Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z3z3: $2702) -> 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: $2700, z2z2: $2701, z3z3: $2702)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': $2702, y3'y3': $2702) -> 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: $2700, z2z2: $2701, x3'x3': $2702)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: $2700, z2z2: $2701, y3'y3': $2702)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': $2702, x3'x3': $2702) -> 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: $2700, z2z2: $2701, y3'y3': $2702)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: $2700, z2z2: $2701, x3'x3': $2702)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': $2701, y2'y2': $2701) -> 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: $2700, x2'x2': $2701, x3x3: $2702)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: $2700, y2'y2': $2701, y3y3: $2702)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': $2701, x2'x2': $2701) -> 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: $2700, y2'y2': $2701, y3y3: $2702)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: $2700, x2'x2': $2701, x3x3: $2702)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': $2700, y1'y1': $2700) -> 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': $2700, x2x2: $2701, x3x3: $2702)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': $2700, y2y2: $2701, y3y3: $2702)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': $2700, x1'x1': $2700) -> 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': $2700, y2y2: $2701, y3y3: $2702)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': $2700, x2x2: $2701, x3x3: $2702)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: $3164, x2x2: $3165, x3x3: $3166, x4x4: $3167)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: $3164, y2y2: $3165, y3y3: $3166, y4y4: $3167)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: ($3164, $3164) -> $3168 order2<$3164>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($3165, $3165) -> $3168 order2<$3165>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V>, 
                      ^@implicit/c/order2?c/order2: ($3166, $3166) -> $3168 order2<$3166>: (cc: V, cc: V) -> ee: E order2std/core/types/order2: V -> V<cc: V>, ^@implicit/field4/order2?field4/order2: ($3167, $3167) -> $3168 order2<$3167>: (dd: V, dd: V) -> ee: E order2std/core/types/order2: V -> V<dd: V> )result: -> 3837 order2<(3833, 3834, 3835, 3836)>: 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: ($3164, $3164) -> $3168 order2<$3164>(x1x1: $3164, y1y1: $3164)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $3164) -> match order2?b/order2: ($3165, $3165) -> $3168 order2<$3165>(x2x2: $3165, y2y2: $3165)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $3165) -> match order2?c/order2: ($3166, $3166) -> $3168 order2<$3166>(x3x3: $3166, y3y3: $3166)
        Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z3z3: $3166) -> match order2?field4/order2: ($3167, $3167) -> $3168 order2<$3167>(x4x4: $3167, y4y4: $3167)
          Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z4z4: $3167) -> 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: $3164, z2z2: $3165, z3z3: $3166, z4z4: $3167)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': $3167, y4'y4': $3167) -> 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: $3164, z2z2: $3165, z3z3: $3166, x4'x4': $3167)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: $3164, z2z2: $3165, z3z3: $3166, y4'y4': $3167)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': $3167, x4'x4': $3167) -> 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: $3164, z2z2: $3165, z3z3: $3166, y4'y4': $3167)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: $3164, z2z2: $3165, z3z3: $3166, x4'x4': $3167)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': $3166, y3'y3': $3166) -> 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: $3164, z2z2: $3165, x3'x3': $3166, x4x4: $3167)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: $3164, z2z2: $3165, y3'y3': $3166, y4y4: $3167)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': $3166, x3'x3': $3166) -> 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: $3164, z2z2: $3165, y3'y3': $3166, y4y4: $3167)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: $3164, z2z2: $3165, x3'x3': $3166, x4x4: $3167)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': $3165, y2'y2': $3165) -> 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: $3164, x2'x2': $3165, x3x3: $3166, x4x4: $3167)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: $3164, y2'y2': $3165, y3y3: $3166, y4y4: $3167)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': $3165, x2'x2': $3165) -> 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: $3164, y2'y2': $3165, y3y3: $3166, y4y4: $3167)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: $3164, x2'x2': $3165, x3x3: $3166, x4x4: $3167)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': $3164, y1'y1': $3164) -> 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': $3164, x2x2: $3165, x3x3: $3166, x4x4: $3167)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': $3164, y2y2: $3165, y3y3: $3166, y4y4: $3167)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': $3164, x1'x1': $3164) -> 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': $3164, y2y2: $3165, y3y3: $3166, y4y4: $3167)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': $3164, x2x2: $3165, x3x3: $3166, x4x4: $3167)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: $3838, x2x2: $3839, x3x3: $3840, x4x4: $3841, x5x5: $3843)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: $3838, y2y2: $3839, y3y3: $3840, y4y4: $3841, y5y5: $3843)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: ($3838, $3838) -> $3842 order2<$3838>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>, ^@implicit/b/order2?b/order2: ($3839, $3839) -> $3842 order2<$3839>: (bb: V, bb: V) -> ee: E order2std/core/types/order2: V -> V<bb: V>, ^@implicit/c/order2?c/order2: ($3840, $3840) -> $3842 order2<$3840>: (cc: V, cc: V) -> ee: E order2std/core/types/order2: V -> V<cc: V>, 
                      ^@implicit/field4/order2?field4/order2: ($3841, $3841) -> $3842 order2<$3841>: (dd: V, dd: V) -> ee: E order2std/core/types/order2: V -> V<dd: V>, ^@implicit/field5/order2?field5/order2: ($3843, $3843) -> $3842 order2<$3843>: (ff: V, ff: V) -> ee: E order2std/core/types/order2: V -> V<ff: V> )result: -> 4752 order2<(4748, 4749, 4750, 4751, 4753)>: 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: ($3838, $3838) -> $3842 order2<$3838>(x1x1: $3838, y1y1: $3838)
    Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z1z1: $3838) -> match order2?b/order2: ($3839, $3839) -> $3842 order2<$3839>(x2x2: $3839, y2y2: $3839)
      Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z2z2: $3839) -> match order2?c/order2: ($3840, $3840) -> $3842 order2<$3840>(x3x3: $3840, y3y3: $3840)
        Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z3z3: $3840) -> match order2?field4/order2: ($3841, $3841) -> $3842 order2<$3841>(x4x4: $3841, y4y4: $3841)
          Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z4z4: $3841) -> match order2?field5/order2: ($3843, $3843) -> $3842 order2<$3843>(x5x5: $3843, y5y5: $3843)
            Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(z5z5: $3843) -> 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: $3838, z2z2: $3839, z3z3: $3840, z4z4: $3841, z5z5: $3843)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': $3843, y5'y5': $3843) -> 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: $3838, z2z2: $3839, z3z3: $3840, z4z4: $3841, x5'x5': $3843)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: $3838, z2z2: $3839, z3z3: $3840, z4z4: $3841, y5'y5': $3843)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': $3843, x5'x5': $3843) -> 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: $3838, z2z2: $3839, z3z3: $3840, z4z4: $3841, y5'y5': $3843)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: $3838, z2z2: $3839, z3z3: $3840, z4z4: $3841, x5'x5': $3843)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': $3841, y4'y4': $3841) -> 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: $3838, z2z2: $3839, z3z3: $3840, x4'x4': $3841, x5x5: $3843)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: $3838, z2z2: $3839, z3z3: $3840, y4'y4': $3841, y5y5: $3843)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': $3841, x4'x4': $3841) -> 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: $3838, z2z2: $3839, z3z3: $3840, y4'y4': $3841, y5y5: $3843)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: $3838, z2z2: $3839, z3z3: $3840, x4'x4': $3841, x5x5: $3843)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': $3840, y3'y3': $3840) -> 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: $3838, z2z2: $3839, x3'x3': $3840, x4x4: $3841, x5x5: $3843)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: $3838, z2z2: $3839, y3'y3': $3840, y4y4: $3841, y5y5: $3843)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': $3840, x3'x3': $3840) -> 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: $3838, z2z2: $3839, y3'y3': $3840, y4y4: $3841, y5y5: $3843)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: $3838, z2z2: $3839, x3'x3': $3840, x4x4: $3841, x5x5: $3843)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': $3839, y2'y2': $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: $3838, x2'x2': $3839, x3x3: $3840, x4x4: $3841, x5x5: $3843)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: $3838, y2'y2': $3839, y3y3: $3840, y4y4: $3841, y5y5: $3843)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': $3839, x2'x2': $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: $3838, y2'y2': $3839, y3y3: $3840, y4y4: $3841, y5y5: $3843)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: $3838, x2'x2': $3839, x3x3: $3840, x4x4: $3841, x5x5: $3843)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': $3838, y1'y1': $3838) -> 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': $3838, x2x2: $3839, x3x3: $3840, x4x4: $3841, x5x5: $3843)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': $3838, y2y2: $3839, y3y3: $3840, y4y4: $3841, y5y5: $3843)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': $3838, x1'x1': $3838) -> 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': $3838, y2y2: $3839, y3y3: $3840, y4y4: $3841, y5y5: $3843)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': $3838, x2x2: $3839, x3x3: $3840, x4x4: $3841, x5x5: $3843)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: ($4812, $4813) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), @implicit/fst/show?fst/show: ($4812) -> $4814 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($4813) -> $4814 string : bb: V -> ee: E stringstd/core/types/string: V)result: -> 5015 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $4814 string xx: ($4812, $4813).fststd/core/types/tuple2/fst: (tuple2 : ($4812, $4813)) -> $4814 $4812.show?fst/show: ($4812) -> $4814 string ++std/core/types/(++): (x : string, y : string) -> $4814 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $4814 string xx: ($4812, $4813).sndstd/core/types/tuple2/snd: (tuple2 : ($4812, $4813)) -> $4814 $4813.show?snd/show: ($4813) -> $4814 string ++std/core/types/(++): (x : string, y : string) -> $4814 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: ($5016, $5017, $5018) : (std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V), @implicit/fst/show?fst/show: ($5016) -> $5019 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($5017) -> $5019 string : bb: V -> ee: E stringstd/core/types/string: V, @implicit/thd/show?thd/show: ($5018) -> $5019 string : cc: V -> ee: E stringstd/core/types/string: V)result: -> 5319 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5019 string xx: ($5016, $5017, $5018).fststd/core/types/tuple3/fst: (tuple3 : ($5016, $5017, $5018)) -> $5019 $5016.show?fst/show: ($5016) -> $5019 string ++std/core/types/(++): (x : string, y : string) -> $5019 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5019 string xx: ($5016, $5017, $5018).sndstd/core/types/tuple3/snd: (tuple3 : ($5016, $5017, $5018)) -> $5019 $5017.show?snd/show: ($5017) -> $5019 string ++std/core/types/(++): (x : string, y : string) -> $5019 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5019 string xx: ($5016, $5017, $5018).thdstd/core/types/tuple3/thd: (tuple3 : ($5016, $5017, $5018)) -> $5019 $5018.show?thd/show: ($5018) -> $5019 string ++std/core/types/(++): (x : string, y : string) -> $5019 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: ($5320, $5321, $5322, $5323) : (std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V), @implicit/fst/show?fst/show: ($5320) -> $5324 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($5321) -> $5324 string : bb: V -> ee: E stringstd/core/types/string: V, 
                                    @implicit/thd/show?thd/show: ($5322) -> $5324 string : cc: V -> ee: E stringstd/core/types/string: V, @implicit/field4/show?field4/show: ($5323) -> $5324 string : dd: V -> ee: E stringstd/core/types/string: V)result: -> 5721 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5324 string xx: ($5320, $5321, $5322, $5323).fststd/core/types/tuple4/fst: (tuple4 : ($5320, $5321, $5322, $5323)) -> $5324 $5320.show?fst/show: ($5320) -> $5324 string ++std/core/types/(++): (x : string, y : string) -> $5324 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5324 string xx: ($5320, $5321, $5322, $5323).sndstd/core/types/tuple4/snd: (tuple4 : ($5320, $5321, $5322, $5323)) -> $5324 $5321.show?snd/show: ($5321) -> $5324 string ++std/core/types/(++): (x : string, y : string) -> $5324 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5324 string xx: ($5320, $5321, $5322, $5323).thdstd/core/types/tuple4/thd: (tuple4 : ($5320, $5321, $5322, $5323)) -> $5324 $5322.show?thd/show: ($5322) -> $5324 string ++std/core/types/(++): (x : string, y : string) -> $5324 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5324 string xx: ($5320, $5321, $5322, $5323).field4std/core/types/tuple4/field4: (tuple4 : ($5320, $5321, $5322, $5323)) -> $5324 $5323.show?field4/show: ($5323) -> $5324 string ++std/core/types/(++): (x : string, y : string) -> $5324 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: ($5722, $5723, $5724, $5725, $5727) : (std/core/types/tuple5: (V, V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V,ff: V), @implicit/fst/show?fst/show: ($5722) -> $5726 string : aa: V -> ee: E stringstd/core/types/string: V, @implicit/snd/show?snd/show: ($5723) -> $5726 string : bb: V -> ee: E stringstd/core/types/string: V, @implicit/thd/show?thd/show: ($5724) -> $5726 string : cc: V -> ee: E stringstd/core/types/string: V, 
                                      @implicit/field4/show?field4/show: ($5725) -> $5726 string : dd: V -> ee: E stringstd/core/types/string: V, @implicit/field5/show?field5/show: ($5727) -> $5726 string : ff: V -> ee: E stringstd/core/types/string: V)result: -> 6211 string : ee: E stringstd/core/types/string: V
  "("literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5726 string xx: ($5722, $5723, $5724, $5725, $5727).fststd/core/types/tuple5/fst: (tuple5 : ($5722, $5723, $5724, $5725, $5727)) -> $5726 $5722.show?fst/show: ($5722) -> $5726 string ++std/core/types/(++): (x : string, y : string) -> $5726 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5726 string xx: ($5722, $5723, $5724, $5725, $5727).sndstd/core/types/tuple5/snd: (tuple5 : ($5722, $5723, $5724, $5725, $5727)) -> $5726 $5723.show?snd/show: ($5723) -> $5726 string ++std/core/types/(++): (x : string, y : string) -> $5726 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5726 string xx: ($5722, $5723, $5724, $5725, $5727).thdstd/core/types/tuple5/thd: (tuple5 : ($5722, $5723, $5724, $5725, $5727)) -> $5726 $5724.show?thd/show: ($5724) -> $5726 string ++std/core/types/(++): (x : string, y : string) -> $5726 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5726 string xx: ($5722, $5723, $5724, $5725, $5727).field4std/core/types/tuple5/field4: (tuple5 : ($5722, $5723, $5724, $5725, $5727)) -> $5726 $5725.show?field4/show: ($5725) -> $5726 string ++std/core/types/(++): (x : string, y : string) -> $5726 string ","literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $5726 string xx: ($5722, $5723, $5724, $5725, $5727).field5std/core/types/tuple5/field5: (tuple5 : ($5722, $5723, $5724, $5725, $5727)) -> $5726 $5727.show?field5/show: ($5727) -> $5726 string ++std/core/types/(++): (x : string, y : string) -> $5726 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: ($6267, $6268) : (std/core/types/tuple2: (V, V) -> Vaa: V,bb: V), showfstshowfst: ($6267) -> $6269 string : aa: V -> ee: E stringstd/core/types/string: V, showsndshowsnd: ($6268) -> $6269 string : bb: V -> ee: E stringstd/core/types/string: V )result: -> 6355 string : ee: E stringstd/core/types/string: V
  showstd/core/tuple/tuple2/show: (x : ($6267, $6268), @implicit/fst/show : ($6267) -> $6269 string, @implicit/snd/show : ($6268) -> $6269 string) -> $6269 string(xx: ($6267, $6268),@implicit/fst/show=showfstshowfst: ($6267) -> $6269 string,@implicit/snd/show=showsndshowsnd: ($6268) -> $6269 string)