==================== Tidy Core ====================
2017-09-19 23:55:00.1476113 UTC

Result size of Tidy Core
  = {terms: 488, types: 817, coercions: 8, joins: 0/0}

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
CoreDump.Tensor.Ounzip.$trModule4 :: GHC.Prim.Addr#
CoreDump.Tensor.Ounzip.$trModule4 = "main"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
CoreDump.Tensor.Ounzip.$trModule3 :: GHC.Types.TrName
CoreDump.Tensor.Ounzip.$trModule3
  = GHC.Types.TrNameS CoreDump.Tensor.Ounzip.$trModule4

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
CoreDump.Tensor.Ounzip.$trModule2 :: GHC.Prim.Addr#
CoreDump.Tensor.Ounzip.$trModule2 = "CoreDump.Tensor.Ounzip"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
CoreDump.Tensor.Ounzip.$trModule1 :: GHC.Types.TrName
CoreDump.Tensor.Ounzip.$trModule1
  = GHC.Types.TrNameS CoreDump.Tensor.Ounzip.$trModule2

-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
CoreDump.Tensor.Ounzip.$trModule :: GHC.Types.Module
CoreDump.Tensor.Ounzip.$trModule
  = GHC.Types.Module
      CoreDump.Tensor.Ounzip.$trModule3 CoreDump.Tensor.Ounzip.$trModule1

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl :: GHC.Prim.Addr#
lvl = "error"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl1 :: [Char]
lvl1 = GHC.CString.unpackCString# lvl

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl2 :: GHC.Prim.Addr#
lvl2 = "static-tensor-0.2.0.0-4LYZSU7cIXNFIrMbd1zb5c"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl3 :: [Char]
lvl3 = GHC.CString.unpackCString# lvl2

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl4 :: GHC.Prim.Addr#
lvl4 = "Data.List.Unrolled"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl5 :: [Char]
lvl5 = GHC.CString.unpackCString# lvl4

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl6 :: GHC.Prim.Addr#
lvl6 = "src\\Data\\List\\Unrolled.hs"#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl7 :: [Char]
lvl7 = GHC.CString.unpackCString# lvl6

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl8 :: Int
lvl8 = GHC.Types.I# 185#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl9 :: Int
lvl9 = GHC.Types.I# 22#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl10 :: Int
lvl10 = GHC.Types.I# 69#

-- RHS size: {terms: 8, types: 0, coercions: 0, joins: 0/0}
lvl11 :: GHC.Stack.Types.SrcLoc
lvl11 = GHC.Stack.Types.SrcLoc lvl3 lvl5 lvl7 lvl8 lvl9 lvl8 lvl10

-- RHS size: {terms: 4, types: 0, coercions: 0, joins: 0/0}
lvl12 :: GHC.Stack.Types.CallStack
lvl12
  = GHC.Stack.Types.PushCallStack
      lvl1 lvl11 GHC.Stack.Types.EmptyCallStack

-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
lvl13 :: GHC.Prim.Addr#
lvl13 = "unzip: Not enough elements in the list."#

-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
lvl14 :: [Char]
lvl14 = GHC.CString.unpackCString# lvl13

-- RHS size: {terms: 3, types: 6, coercions: 4, joins: 0/0}
lvl15 :: ([Float], [Float])
lvl15
  = error
      @ 'GHC.Types.LiftedRep
      @ ([Float], [Float])
      (lvl12 `cast` <Co:4>)
      lvl14

-- RHS size: {terms: 412, types: 632, coercions: 4, joins: 0/0}
CoreDump.Tensor.Ounzip.$wounzip_
  :: [(Float, Float)]
     -> (# Tensor '[2, 3, 4] Float, Tensor '[2, 3, 4] Float #)
CoreDump.Tensor.Ounzip.$wounzip_
  = \ (w :: [(Float, Float)]) ->
      case w of {
        [] -> case lvl15 of wild1 { };
        : x xs ->
          case x of { (a1, b1) ->
          case xs of {
            [] -> case lvl15 of wild3 { };
            : x1 xs1 ->
              case x1 of { (a2, b2) ->
              case xs1 of {
                [] -> case lvl15 of wild5 { };
                : x2 xs2 ->
                  case x2 of { (a3, b3) ->
                  case xs2 of {
                    [] -> case lvl15 of wild7 { };
                    : x3 xs3 ->
                      case x3 of { (a4, b4) ->
                      case xs3 of {
                        [] -> case lvl15 of wild9 { };
                        : x4 xs4 ->
                          case x4 of { (a5, b5) ->
                          case xs4 of {
                            [] -> case lvl15 of wild11 { };
                            : x5 xs5 ->
                              case x5 of { (a6, b6) ->
                              case xs5 of {
                                [] -> case lvl15 of wild13 { };
                                : x6 xs6 ->
                                  case x6 of { (a7, b7) ->
                                  case xs6 of {
                                    [] -> case lvl15 of wild15 { };
                                    : x7 xs7 ->
                                      case x7 of { (a8, b8) ->
                                      case xs7 of {
                                        [] -> case lvl15 of wild17 { };
                                        : x8 xs8 ->
                                          case x8 of { (a9, b9) ->
                                          case xs8 of {
                                            [] -> case lvl15 of wild19 { };
                                            : x9 xs9 ->
                                              case x9 of { (a10, b10) ->
                                              case xs9 of {
                                                [] -> case lvl15 of wild21 { };
                                                : x10 xs10 ->
                                                  case x10 of { (a11, b11) ->
                                                  case xs10 of {
                                                    [] -> case lvl15 of wild23 { };
                                                    : x11 xs11 ->
                                                      case x11 of { (a12, b12) ->
                                                      case xs11 of {
                                                        [] -> case lvl15 of wild25 { };
                                                        : x12 xs12 ->
                                                          case x12 of { (a13, b13) ->
                                                          case xs12 of {
                                                            [] -> case lvl15 of wild27 { };
                                                            : x13 xs13 ->
                                                              case x13 of { (a14, b14) ->
                                                              case xs13 of {
                                                                [] -> case lvl15 of wild29 { };
                                                                : x14 xs14 ->
                                                                  case x14 of { (a15, b15) ->
                                                                  case xs14 of {
                                                                    [] -> case lvl15 of wild31 { };
                                                                    : x15 xs15 ->
                                                                      case x15 of { (a16, b16) ->
                                                                      case xs15 of {
                                                                        [] ->
                                                                          case lvl15 of wild33 { };
                                                                        : x16 xs16 ->
                                                                          case x16 of
                                                                          { (a17, b17) ->
                                                                          case xs16 of {
                                                                            [] ->
                                                                              case lvl15 of wild35 {
                                                                              };
                                                                            : x17 xs17 ->
                                                                              case x17 of
                                                                              { (a18, b18) ->
                                                                              case xs17 of {
                                                                                [] ->
                                                                                  case lvl15
                                                                                  of wild37 {
                                                                                  };
                                                                                : x18 xs18 ->
                                                                                  case x18 of
                                                                                  { (a19, b19) ->
                                                                                  case xs18 of {
                                                                                    [] ->
                                                                                      case lvl15
                                                                                      of wild39 {
                                                                                      };
                                                                                    : x19 xs19 ->
                                                                                      case x19 of
                                                                                      { (a20,
                                                                                         b20) ->
                                                                                      case xs19 of {
                                                                                        [] ->
                                                                                          case lvl15
                                                                                          of wild41 {
                                                                                          };
                                                                                        : x20
                                                                                          xs20 ->
                                                                                          case x20
                                                                                          of
                                                                                          { (a21,
                                                                                             b21) ->
                                                                                          case xs20
                                                                                          of {
                                                                                            [] ->
                                                                                              case lvl15
                                                                                              of wild43 {
                                                                                              };
                                                                                            : x21
                                                                                              xs21 ->
                                                                                              case x21
                                                                                              of
                                                                                              { (a22,
                                                                                                 b22) ->
                                                                                              case xs21
                                                                                              of {
                                                                                                [] ->
                                                                                                  case lvl15
                                                                                                  of wild45 {
                                                                                                  };
                                                                                                : x22
                                                                                                  xs22 ->
                                                                                                  case x22
                                                                                                  of
                                                                                                  { (a23,
                                                                                                     b23) ->
                                                                                                  case xs22
                                                                                                  of {
                                                                                                    [] ->
                                                                                                      case lvl15
                                                                                                      of wild47 {
                                                                                                      };
                                                                                                    : x23
                                                                                                      xs23 ->
                                                                                                      case x23
                                                                                                      of
                                                                                                      { (a24,
                                                                                                         b24) ->
                                                                                                      case a1
                                                                                                      of
                                                                                                      { GHC.Types.F# dt1 ->
                                                                                                      case a2
                                                                                                      of
                                                                                                      { GHC.Types.F# dt3 ->
                                                                                                      case a3
                                                                                                      of
                                                                                                      { GHC.Types.F# dt5 ->
                                                                                                      case a4
                                                                                                      of
                                                                                                      { GHC.Types.F# dt7 ->
                                                                                                      case a5
                                                                                                      of
                                                                                                      { GHC.Types.F# dt9 ->
                                                                                                      case a6
                                                                                                      of
                                                                                                      { GHC.Types.F# dt11 ->
                                                                                                      case a7
                                                                                                      of
                                                                                                      { GHC.Types.F# dt13 ->
                                                                                                      case a8
                                                                                                      of
                                                                                                      { GHC.Types.F# dt15 ->
                                                                                                      case a9
                                                                                                      of
                                                                                                      { GHC.Types.F# dt17 ->
                                                                                                      case a10
                                                                                                      of
                                                                                                      { GHC.Types.F# dt19 ->
                                                                                                      case a11
                                                                                                      of
                                                                                                      { GHC.Types.F# dt21 ->
                                                                                                      case a12
                                                                                                      of
                                                                                                      { GHC.Types.F# dt23 ->
                                                                                                      case a13
                                                                                                      of
                                                                                                      { GHC.Types.F# dt25 ->
                                                                                                      case a14
                                                                                                      of
                                                                                                      { GHC.Types.F# dt27 ->
                                                                                                      case a15
                                                                                                      of
                                                                                                      { GHC.Types.F# dt29 ->
                                                                                                      case a16
                                                                                                      of
                                                                                                      { GHC.Types.F# dt31 ->
                                                                                                      case a17
                                                                                                      of
                                                                                                      { GHC.Types.F# dt33 ->
                                                                                                      case a18
                                                                                                      of
                                                                                                      { GHC.Types.F# dt35 ->
                                                                                                      case a19
                                                                                                      of
                                                                                                      { GHC.Types.F# dt37 ->
                                                                                                      case a20
                                                                                                      of
                                                                                                      { GHC.Types.F# dt39 ->
                                                                                                      case a21
                                                                                                      of
                                                                                                      { GHC.Types.F# dt41 ->
                                                                                                      case a22
                                                                                                      of
                                                                                                      { GHC.Types.F# dt43 ->
                                                                                                      case a23
                                                                                                      of
                                                                                                      { GHC.Types.F# dt45 ->
                                                                                                      case a24
                                                                                                      of
                                                                                                      { GHC.Types.F# dt47 ->
                                                                                                      case b1
                                                                                                      of
                                                                                                      { GHC.Types.F# dt49 ->
                                                                                                      case b2
                                                                                                      of
                                                                                                      { GHC.Types.F# dt51 ->
                                                                                                      case b3
                                                                                                      of
                                                                                                      { GHC.Types.F# dt53 ->
                                                                                                      case b4
                                                                                                      of
                                                                                                      { GHC.Types.F# dt55 ->
                                                                                                      case b5
                                                                                                      of
                                                                                                      { GHC.Types.F# dt57 ->
                                                                                                      case b6
                                                                                                      of
                                                                                                      { GHC.Types.F# dt59 ->
                                                                                                      case b7
                                                                                                      of
                                                                                                      { GHC.Types.F# dt61 ->
                                                                                                      case b8
                                                                                                      of
                                                                                                      { GHC.Types.F# dt63 ->
                                                                                                      case b9
                                                                                                      of
                                                                                                      { GHC.Types.F# dt65 ->
                                                                                                      case b10
                                                                                                      of
                                                                                                      { GHC.Types.F# dt67 ->
                                                                                                      case b11
                                                                                                      of
                                                                                                      { GHC.Types.F# dt69 ->
                                                                                                      case b12
                                                                                                      of
                                                                                                      { GHC.Types.F# dt71 ->
                                                                                                      case b13
                                                                                                      of
                                                                                                      { GHC.Types.F# dt73 ->
                                                                                                      case b14
                                                                                                      of
                                                                                                      { GHC.Types.F# dt75 ->
                                                                                                      case b15
                                                                                                      of
                                                                                                      { GHC.Types.F# dt77 ->
                                                                                                      case b16
                                                                                                      of
                                                                                                      { GHC.Types.F# dt79 ->
                                                                                                      case b17
                                                                                                      of
                                                                                                      { GHC.Types.F# dt81 ->
                                                                                                      case b18
                                                                                                      of
                                                                                                      { GHC.Types.F# dt83 ->
                                                                                                      case b19
                                                                                                      of
                                                                                                      { GHC.Types.F# dt85 ->
                                                                                                      case b20
                                                                                                      of
                                                                                                      { GHC.Types.F# dt87 ->
                                                                                                      case b21
                                                                                                      of
                                                                                                      { GHC.Types.F# dt89 ->
                                                                                                      case b22
                                                                                                      of
                                                                                                      { GHC.Types.F# dt91 ->
                                                                                                      case b23
                                                                                                      of
                                                                                                      { GHC.Types.F# dt93 ->
                                                                                                      case b24
                                                                                                      of
                                                                                                      { GHC.Types.F# dt95 ->
                                                                                                      (# (TensorInstances.Tensor'2'3'4'Float
                                                                                                            dt1
                                                                                                            dt3
                                                                                                            dt5
                                                                                                            dt7
                                                                                                            dt9
                                                                                                            dt11
                                                                                                            dt13
                                                                                                            dt15
                                                                                                            dt17
                                                                                                            dt19
                                                                                                            dt21
                                                                                                            dt23
                                                                                                            dt25
                                                                                                            dt27
                                                                                                            dt29
                                                                                                            dt31
                                                                                                            dt33
                                                                                                            dt35
                                                                                                            dt37
                                                                                                            dt39
                                                                                                            dt41
                                                                                                            dt43
                                                                                                            dt45
                                                                                                            dt47)
                                                                                                         `cast` <Co:2>,
                                                                                                         (TensorInstances.Tensor'2'3'4'Float
                                                                                                            dt49
                                                                                                            dt51
                                                                                                            dt53
                                                                                                            dt55
                                                                                                            dt57
                                                                                                            dt59
                                                                                                            dt61
                                                                                                            dt63
                                                                                                            dt65
                                                                                                            dt67
                                                                                                            dt69
                                                                                                            dt71
                                                                                                            dt73
                                                                                                            dt75
                                                                                                            dt77
                                                                                                            dt79
                                                                                                            dt81
                                                                                                            dt83
                                                                                                            dt85
                                                                                                            dt87
                                                                                                            dt89
                                                                                                            dt91
                                                                                                            dt93
                                                                                                            dt95)
                                                                                                         `cast` <Co:2> #)
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                      }
                                                                                                  }
                                                                                                  }
                                                                                              }
                                                                                              }
                                                                                          }
                                                                                          }
                                                                                      }
                                                                                      }
                                                                                  }
                                                                                  }
                                                                              }
                                                                              }
                                                                          }
                                                                          }
                                                                      }
                                                                      }
                                                                  }
                                                                  }
                                                              }
                                                              }
                                                          }
                                                          }
                                                      }
                                                      }
                                                  }
                                                  }
                                              }
                                              }
                                          }
                                          }
                                      }
                                      }
                                  }
                                  }
                              }
                              }
                          }
                          }
                      }
                      }
                  }
                  }
              }
              }
          }
          }
      }

-- RHS size: {terms: 8, types: 85, coercions: 0, joins: 0/0}
ounzip_
  :: [(Float, Float)]
     -> (Tensor '[2, 3, 4] Float, Tensor '[2, 3, 4] Float)
ounzip_
  = \ (w :: [(Float, Float)]) ->
      case CoreDump.Tensor.Ounzip.$wounzip_ w of { (# ww1, ww2 #) ->
      (ww1, ww2)
      }