static-tensor-0.1.0.0: tests/CoreDump/Tensor/EnumFromStepN.dump-simpl.ghc821.golden

==================== Tidy Core ====================
2017-09-08 01:36:26.2673497 UTC

Result size of Tidy Core
  = {terms: 138, types: 48, coercions: 2, joins: 0/22}

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

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

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

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

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

-- RHS size: {terms: 123, types: 28, coercions: 2, joins: 0/22}
enumFromStepN_ :: Float -> Float -> Tensor '[2, 3, 4] Float
enumFromStepN_
  = \ (a6 :: Float) (x :: Float) ->
      case a6 of { GHC.Types.F# x1 ->
      case x of { GHC.Types.F# y ->
      let {
        a1 :: GHC.Prim.Float#
        a1 = GHC.Prim.plusFloat# x1 y } in
      let {
        a2 :: GHC.Prim.Float#
        a2 = GHC.Prim.plusFloat# a1 y } in
      let {
        a3 :: GHC.Prim.Float#
        a3 = GHC.Prim.plusFloat# a2 y } in
      let {
        a4 :: GHC.Prim.Float#
        a4 = GHC.Prim.plusFloat# a3 y } in
      let {
        a5 :: GHC.Prim.Float#
        a5 = GHC.Prim.plusFloat# a4 y } in
      let {
        a7 :: GHC.Prim.Float#
        a7 = GHC.Prim.plusFloat# a5 y } in
      let {
        a8 :: GHC.Prim.Float#
        a8 = GHC.Prim.plusFloat# a7 y } in
      let {
        a9 :: GHC.Prim.Float#
        a9 = GHC.Prim.plusFloat# a8 y } in
      let {
        a10 :: GHC.Prim.Float#
        a10 = GHC.Prim.plusFloat# a9 y } in
      let {
        a11 :: GHC.Prim.Float#
        a11 = GHC.Prim.plusFloat# a10 y } in
      let {
        a12 :: GHC.Prim.Float#
        a12 = GHC.Prim.plusFloat# a11 y } in
      let {
        a13 :: GHC.Prim.Float#
        a13 = GHC.Prim.plusFloat# a12 y } in
      let {
        a14 :: GHC.Prim.Float#
        a14 = GHC.Prim.plusFloat# a13 y } in
      let {
        a15 :: GHC.Prim.Float#
        a15 = GHC.Prim.plusFloat# a14 y } in
      let {
        a16 :: GHC.Prim.Float#
        a16 = GHC.Prim.plusFloat# a15 y } in
      let {
        a17 :: GHC.Prim.Float#
        a17 = GHC.Prim.plusFloat# a16 y } in
      let {
        a18 :: GHC.Prim.Float#
        a18 = GHC.Prim.plusFloat# a17 y } in
      let {
        a19 :: GHC.Prim.Float#
        a19 = GHC.Prim.plusFloat# a18 y } in
      let {
        a20 :: GHC.Prim.Float#
        a20 = GHC.Prim.plusFloat# a19 y } in
      let {
        a21 :: GHC.Prim.Float#
        a21 = GHC.Prim.plusFloat# a20 y } in
      let {
        a22 :: GHC.Prim.Float#
        a22 = GHC.Prim.plusFloat# a21 y } in
      let {
        a23 :: GHC.Prim.Float#
        a23 = GHC.Prim.plusFloat# a22 y } in
      (TensorInstances.Tensor'2'3'4'Float
         x1
         a1
         a2
         a3
         a4
         a5
         a7
         a8
         a9
         a10
         a11
         a12
         a13
         a14
         a15
         a16
         a17
         a18
         a19
         a20
         a21
         a22
         a23
         (GHC.Prim.plusFloat# a23 y))
      `cast` <Co:2>
      }
      }