// 1D FFT.
func.func @fft_1d() {
  %input = util.unfoldable_constant dense<[(0.21740782,0.059113156), (0.778621,0.6152795), (0.6581351,0.72274965), (0.85420084,0.5449456), (0.8268271,0.059995476), (0.1314825,0.99552083), (0.07452258,0.97213143), (0.72783166,0.64232296), (0.21783765,0.077186435), (0.2372208,0.9866753), (0.76789004,0.7888627), (0.7672063,0.11202169), (0.20171618,0.71090525), (0.5671336,0.5172962), (0.5653311,0.13171488), (0.6019718,0.22600187), (0.7669061,0.99419916), (0.7296996,0.19616151), (0.49405196,0.23033695), (0.91676044,0.14108129), (0.25893882,0.5168747), (0.0022013448,0.45859325), (0.6937525,0.12294605), (0.14645115,0.8247891), (0.6886818,0.58247185), (0.15621811,0.4682121), (0.7700238,0.4526145), (0.8244305,0.7325929), (0.004420892,0.5293484), (0.0894202,0.36284673), (0.297367,0.76520026), (0.7746221,0.8835885)]> : tensor<32xcomplex<f32>>
  %0 = stablehlo.fft %input, type = FFT, length = [32] : (tensor<32xcomplex<f32>>) -> tensor<32xcomplex<f32>>
  %1 = stablehlo.real %0 : (tensor<32xcomplex<f32>>) -> tensor<32xf32>
  %2 = stablehlo.imag %0 : (tensor<32xcomplex<f32>>) -> tensor<32xf32>
  check.expect_almost_eq_const(%1, dense<[15.809282, 0.21465153, 1.181782, -0.60642904, 0.013650537, -0.9517257, 0.43036938, 0.98342496, -0.6450963, -2.5143266, -0.7090554, -1.3734092, -0.39120948, 0.28289393, -0.8894674, -0.40649498, -0.801661, -0.7713141, -2.8925278, -0.5026806, 1.5893525, -3.5212724, 1.3363503, 2.5882864, -1.6315789, -0.8786793, 0.077445, 0.4787432, 1.1839279, -0.29849604, 2.0874598, -1.5151438]> : tensor<32xf32>) : tensor<32xf32>
  check.expect_almost_eq_const(%2, dense<[16.424582, 1.0421104, -1.6126406, -1.8765254, -2.0437074, -0.34451416, 1.5531765, 0.13303947, 2.2650156, -4.2676077, -1.4725999, -1.0876011, -1.3087398, 1.2196933, 1.8778068, -3.174349, -0.9912782, -0.66518277, 0.6316352, -2.4745326, -0.28285468, 0.21321717, 2.3605132, -4.4211693, -3.57794, -1.9363232, 0.5097058, -0.54355776, 3.218689, 1.0246719, -0.6983651, 2.1972544]> : tensor<32xf32>) : tensor<32xf32>
  return
}

// 1D IFFT. This is the inverse of the @fft_1d() so should give back the original inputs (within floating point error).
func.func @ifft_1d() {
  %input = util.unfoldable_constant dense<[(15.809282,16.424582), (0.21465153,1.0421104), (1.181782,-1.6126406), (-0.60642904,-1.8765254), (0.013650537,-2.0437074), (-0.9517257,-0.34451416), (0.43036938,1.5531765), (0.98342496,0.13303947), (-0.6450963,2.2650156), (-2.5143266,-4.2676077), (-0.7090554,-1.4725999), (-1.3734092,-1.0876011), (-0.39120948,-1.3087398), (0.28289393,1.2196933), (-0.8894674,1.8778068), (-0.40649498,-3.174349), (-0.801661,-0.9912782), (-0.7713141,-0.66518277), (-2.8925278,0.6316352), (-0.5026806,-2.4745326), (1.5893525,-0.28285468), (-3.5212724,0.21321717), (1.3363503,2.3605132), (2.5882864,-4.4211693), (-1.6315789,-3.57794), (-0.8786793,-1.9363232), (0.077445,0.5097058), (0.4787432,-0.54355776), (1.1839279,3.218689), (-0.29849604,1.0246719), (2.0874598,-0.6983651), (-1.5151438,2.1972544)]> : tensor<32xcomplex<f32>>
  %0 = stablehlo.fft %input, type = IFFT, length = [32] : (tensor<32xcomplex<f32>>) -> tensor<32xcomplex<f32>>
  %1 = stablehlo.real %0 : (tensor<32xcomplex<f32>>) -> tensor<32xf32>
  %2 = stablehlo.imag %0 : (tensor<32xcomplex<f32>>) -> tensor<32xf32>
  check.expect_almost_eq_const(%1, dense<[0.21740788, 0.77862084, 0.65813524, 0.8542007, 0.8268271, 0.13148248, 0.074522644, 0.72783166, 0.21783769, 0.23722076, 0.7678901, 0.7672063, 0.20171624, 0.56713355, 0.5653311, 0.60197186, 0.7669061, 0.7296995, 0.49405202, 0.91676044, 0.25893885, 0.0022013485, 0.6937525, 0.1464513, 0.68868184, 0.15621811, 0.7700238, 0.82443047, 0.0044209138, 0.08942017, 0.29736707, 0.7746221]> : tensor<32xf32>) : tensor<32xf32>
  check.expect_almost_eq_const(%2, dense<[0.059113204, 0.61527944, 0.72274965, 0.54494566, 0.059995517, 0.99552083, 0.9721315, 0.642323, 0.077186525, 0.98667526, 0.7888627, 0.112021744, 0.7109053, 0.51729625, 0.13171494, 0.22600201, 0.9941992, 0.19616154, 0.23033696, 0.14108133, 0.5168747, 0.45859325, 0.12294614, 0.82478905, 0.5824719, 0.4682121, 0.45261455, 0.7325928, 0.5293485, 0.3628468, 0.7652003, 0.88358855]> : tensor<32xf32>) : tensor<32xf32>
  return
}

// 1D RFFT.
func.func @rfft_1d() {
  %input = util.unfoldable_constant dense<[0.7555577, 0.66894025, 0.36586154, 0.24478266, 0.7804641, 0.9256327, 0.42047995, 0.44436365, 0.9899847, 0.97323716, 0.21359204, 0.23445652, 0.38268244, 0.9832261, 0.81922436, 0.033826284, 0.87232935, 0.9702218, 0.795888, 0.05799015, 0.22904389, 0.42274877, 0.70018625, 0.46720484, 0.04191081, 0.26426974, 0.123912655, 0.6813819, 0.78704375, 0.16205642, 0.33862734, 0.43718913]> : tensor<32xf32>
  %0 = stablehlo.fft %input, type = RFFT, length = [32] : (tensor<32xf32>) -> tensor<17xcomplex<f32>>
  %1 = stablehlo.real %0 : (tensor<17xcomplex<f32>>) -> tensor<17xf32>
  %2 = stablehlo.imag %0 : (tensor<17xcomplex<f32>>) -> tensor<17xf32>
  check.expect_almost_eq_const(%1, dense<[16.588318, -0.46602482, 0.8568451, -1.1161734, 0.86731994, -0.5296755, 0.7260204, 3.421573, 1.0612442, -0.33810878, -0.7522839, -1.0411217, 0.09377679, -0.48347437, 1.5533843, -0.38116747, 0.6452608]> : tensor<17xf32>) : tensor<17xf32>
  check.expect_almost_eq_const(%2, dense<[0.0, -2.0378456, -0.33985636, 0.6871074, 0.62438464, -0.90058994, -1.6517396, 2.8402321, -2.7691374, 0.4236927, -0.21823317, 1.0264674, -0.9341428, -0.76218516, 0.45277753, -0.24614418, 0.0]> : tensor<17xf32>) : tensor<17xf32>
  return
}

// 1D IRFFT. This is the inverse of the @rfft_1d() so should give back the original inputs (within floating point error).
func.func @irfft_1d() {
  %input = util.unfoldable_constant dense<[(16.588318,0.0), (-0.46602482,-2.0378456), (0.8568451,-0.33985636), (-1.1161734,0.6871074), (0.86731994,0.62438464), (-0.5296755,-0.90058994), (0.7260204,-1.6517396), (3.421573,2.8402321), (1.0612442,-2.7691374), (-0.33810878,0.4236927), (-0.7522839,-0.21823317), (-1.0411217,1.0264674), (0.09377679,-0.9341428), (-0.48347437,-0.76218516), (1.5533843,0.45277753), (-0.38116747,-0.24614418), (0.6452608,0.0)]> : tensor<17xcomplex<f32>>
  %0 = stablehlo.fft %input, type = IRFFT, length = [32] : (tensor<17xcomplex<f32>>) -> tensor<32xf32>
  check.expect_almost_eq_const(%0, dense<[0.75555766, 0.6689402, 0.3658616, 0.24478275, 0.78046405, 0.9256327, 0.42048004, 0.4443637, 0.98998463, 0.97323704, 0.21359204, 0.2344566, 0.38268244, 0.9832261, 0.81922436, 0.033826366, 0.87232935, 0.97022176, 0.795888, 0.05799026, 0.22904384, 0.42274877, 0.7001864, 0.46720487, 0.041910768, 0.26426968, 0.12391268, 0.6813819, 0.7870437, 0.16205639, 0.33862743, 0.43718916]> : tensor<32xf32>) : tensor<32xf32>
  return
}

// 1D FFT on the innermost dimension of a 2D tensor.
func.func @fft_2d() {
  %input = util.unfoldable_constant dense<[
    [(0.42454708,0.7497621), (0.041191377,0.24758165), (0.9155005,0.30770782), (0.69764674,0.47274446), (0.27280706,0.09685069), (0.27244803,0.6469661), (0.45826593,0.06985904), (0.17154603,0.5261565), (0.6523637,0.820176), (0.32919556,0.4717106), (0.8333855,0.95131546), (0.89933527,0.8346497), (0.3267901,0.9024905), (0.47070992,0.43240488), (0.16493955,0.4907118), (0.8751768,0.30994684)],
    [(0.072277926,0.5039501), (0.61777425,0.6453685), (0.41861197,0.08201122), (0.30265653,0.91535634), (0.7986402,0.9821573), (0.3239637,0.003923847), (0.75269574,0.21496418), (0.17242455,0.61933064), (0.01895543,0.80924535), (0.5124663,0.7291264), (0.59209484,0.5294732), (0.33796164,0.42183158), (0.7656568,0.73263705), (0.35979486,0.37526408), (0.164532,0.8300676), (0.85192627,0.24418339)],
    [(0.33077067,0.4551394), (0.3496145,0.45954412), (0.79393107,0.29244488), (0.34820843,0.94946045), (0.08508753,0.024036057), (0.47641373,0.53241944), (0.23593518,0.4791656), (0.79054934,0.093083896), (0.73827904,0.6110654), (0.7532118,0.99266475), (0.22236909,0.5867702), (0.78232795,0.8468902), (0.5382191,0.3066704), (0.15715897,0.5654445), (0.55649596,0.6326622), (0.12317861,0.5280109)],
    [(0.21837069,0.71890926), (0.7455676,0.44287434), (0.07003461,0.06407995), (0.6162736,0.9908965), (0.61905116,0.6671045), (0.042929675,0.7973596), (0.98639303,0.54450244), (0.6618752,0.43036643), (0.836061,0.317677), (0.73150545,0.007642518), (0.74348444,0.84124154), (0.075450204,0.2211669), (0.00040107843,0.36333412), (0.583956,0.46722978), (0.7215287,0.21090023), (0.27178788,0.6077055)]
    ]> : tensor<4x16xcomplex<f32>>
  %0 = stablehlo.fft %input, type = FFT, length = [16] : (tensor<4x16xcomplex<f32>>) -> tensor<4x16xcomplex<f32>>
  %1 = stablehlo.real %0 : (tensor<4x16xcomplex<f32>>) -> tensor<4x16xf32>
  %2 = stablehlo.imag %0 : (tensor<4x16xcomplex<f32>>) -> tensor<4x16xf32>
  check.expect_almost_eq_const(%1, dense<[
    [7.805849, -1.6919737, 0.60172385, 0.18577386, -1.0404179, -0.24456988, 0.51018083, 0.6593251, 0.2913494, -2.1790113, 1.7498081, -0.2368039, -0.35074925, -0.018270746, -0.9524586, 1.7029977],
    [7.0624332, -0.03740543, -0.28083432, 0.11331892, -0.7194233, 1.5153583, -0.5878404, -0.48429328, 0.10449672, -1.9367342, -3.5323877, -0.93127775, 0.1746149, 1.6701523, -1.4911921, 0.5174611],
    [7.281751, -1.9599283, 1.4732273, -1.7071457, 0.01625204, -2.2114697, 1.5814412, 1.7941546, -0.27957582, 1.2079792, -1.0469666, -0.43757004, -0.24900198, 0.2028476, -0.22472948, -0.1489349],
    [7.92467, -0.10961914, 0.90454286, -1.8976498, -1.3825861, 1.6239735, -0.93979514, -0.22308028, 0.46597958, -2.472485, 0.2652536, 0.7544172, -0.31252754, -0.29754913, 1.5099164, -2.31953]
    ]> : tensor<4x16xf32>) : tensor<4x16xf32>
  check.expect_almost_eq_const(%2, dense<[
    [8.331034, -0.31785518, -1.2684538, 0.89480937, 2.2798452, 0.8055793, 2.1586416, 1.359981, 0.44671297, -0.5609837, 0.15828645, -1.3595346, -0.78047466, 0.007536173, 1.2339137, -1.3928434],
    [8.638891, -0.32050958, -0.17059809, -1.1554592, 1.2224436, 1.3143142, -0.7213407, 0.5179115, 0.73012114, -0.7054142, -0.81955785, -0.21269265, 1.5205038, -1.6415049, 0.10510093, -0.23900717],
    [8.355473, -0.0135094635, -0.5539615, -1.1374638, -0.28626633, 0.44947028, 1.0547199, -0.48714536, -1.5795641, 0.05378939, 1.57722, -0.23645878, -0.90199685, 0.6990721, 0.8640148, -0.57516223],
    [7.6929903, -0.13423741, -0.2282129, 1.5490448, -0.07227099, 0.07735066, -0.61968464, -0.9431027, -0.23749232, -1.2936282, 2.0293136, 2.639404, 0.88487256, 0.48084372, -1.1568255, 0.8341831]
    ]> : tensor<4x16xf32>) : tensor<4x16xf32>
  return
}

// 1D IFFT on the innermost dimension of a 2D tensor. This is the inverse of the @fft_2d() so should give back the original inputs (within floating point error).
func.func @ifft_2d() {
  %input = util.unfoldable_constant dense<[
    [(7.805849,8.331034), (-1.6919737,-0.31785518), (0.60172385,-1.2684538), (0.18577386,0.89480937), (-1.0404179,2.2798452), (-0.24456988,0.8055793), (0.51018083,2.1586416), (0.6593251,1.359981), (0.2913494,0.44671297), (-2.1790113,-0.5609837), (1.7498081,0.15828645), (-0.2368039,-1.3595346), (-0.35074925,-0.78047466), (-0.018270746,0.007536173), (-0.9524586,1.2339137), (1.7029977,-1.3928434)],
    [(7.0624332,8.638891), (-0.03740543,-0.32050958), (-0.28083432,-0.17059809), (0.11331892,-1.1554592), (-0.7194233,1.2224436), (1.5153583,1.3143142), (-0.5878404,-0.7213407), (-0.48429328,0.5179115), (0.10449672,0.73012114), (-1.9367342,-0.7054142), (-3.5323877,-0.81955785), (-0.93127775,-0.21269265), (0.1746149,1.5205038), (1.6701523,-1.6415049), (-1.4911921,0.10510093), (0.5174611,-0.23900717)],
    [(7.281751,8.355473), (-1.9599283,-0.0135094635), (1.4732273,-0.5539615), (-1.7071457,-1.1374638), (0.01625204,-0.28626633), (-2.2114697,0.44947028), (1.5814412,1.0547199), (1.7941546,-0.48714536), (-0.27957582,-1.5795641), (1.2079792,0.05378939), (-1.0469666,1.57722), (-0.43757004,-0.23645878), (-0.24900198,-0.90199685), (0.2028476,0.6990721), (-0.22472948,0.8640148), (-0.1489349,-0.57516223)],
    [(7.92467,7.6929903), (-0.10961914,-0.13423741), (0.90454286,-0.2282129), (-1.8976498,1.5490448), (-1.3825861,-0.07227099), (1.6239735,0.07735066), (-0.93979514,-0.61968464), (-0.22308028,-0.9431027), (0.46597958,-0.23749232), (-2.472485,-1.2936282), (0.2652536,2.0293136), (0.7544172,2.639404), (-0.31252754,0.88487256), (-0.29754913,0.48084372), (1.5099164,-1.1568255), (-2.31953,0.8341831)]
    ]> : tensor<4x16xcomplex<f32>>
  %0 = stablehlo.fft %input, type = IFFT, length = [16] : (tensor<4x16xcomplex<f32>>) -> tensor<4x16xcomplex<f32>>
  %1 = stablehlo.real %0 : (tensor<4x16xcomplex<f32>>) -> tensor<4x16xf32>
  %2 = stablehlo.imag %0 : (tensor<4x16xcomplex<f32>>) -> tensor<4x16xf32>
  check.expect_almost_eq_const(%1, dense<[
    [0.42454705, 0.0411914, 0.9155005, 0.69764674, 0.27280706, 0.27244806, 0.4582658, 0.17154607, 0.65236366, 0.32919556, 0.83338547, 0.89933527, 0.3267901, 0.47070992, 0.1649395, 0.8751768],
    [0.07227796, 0.61777425, 0.418612, 0.3026565, 0.79864013, 0.3239637, 0.7526958, 0.17242464, 0.01895547, 0.5124663, 0.5920949, 0.33796164, 0.7656568, 0.35979486, 0.16453204, 0.8519262],
    [0.33077067, 0.34961456, 0.7939311, 0.34820837, 0.08508754, 0.47641376, 0.23593518, 0.79054934, 0.73827904, 0.7532118, 0.22236907, 0.78232795, 0.5382191, 0.157159, 0.5564959, 0.12317866],
    [0.21837068, 0.7455676, 0.07003465, 0.6162735, 0.6190512, 0.04292959, 0.9863931, 0.6618751, 0.836061, 0.73150545, 0.7434845, 0.07545018, 0.00040110946, 0.58395594, 0.72152877, 0.27178788]
    ]> : tensor<4x16xf32>) : tensor<4x16xf32>
  check.expect_almost_eq_const(%2, dense<[
    [0.74976206, 0.24758163, 0.3077078, 0.47274446, 0.09685066, 0.646966, 0.06985897, 0.5261565, 0.820176, 0.47171053, 0.9513154, 0.8346497, 0.9024905, 0.43240485, 0.49071175, 0.30994684],
    [0.5039502, 0.6453686, 0.08201127, 0.91535634, 0.98215735, 0.003923863, 0.21496421, 0.61933064, 0.8092454, 0.72912645, 0.5294732, 0.42183167, 0.73263717, 0.3752641, 0.8300676, 0.24418351],
    [0.4551394, 0.45954415, 0.29244488, 0.94946045, 0.024036065, 0.5324193, 0.47916567, 0.09308392, 0.6110654, 0.9926647, 0.5867702, 0.8468903, 0.3066705, 0.56544447, 0.6326622, 0.52801096],
    [0.7189092, 0.44287425, 0.06407991, 0.9908966, 0.6671045, 0.7973596, 0.5445024, 0.43036646, 0.31767696, 0.007642463, 0.8412415, 0.221167, 0.3633341, 0.46722975, 0.21090023, 0.6077054]
    ]> : tensor<4x16xf32>) : tensor<4x16xf32>
  return
}

// 1D RFFT on the innermost dimension of a 2D tensor.
func.func @rfft_2d() {
  %input = util.unfoldable_constant dense<[
    [0.42454708, 0.041191377, 0.9155005, 0.69764674, 0.27280706, 0.27244803, 0.45826593, 0.17154603, 0.6523637, 0.32919556, 0.8333855, 0.89933527, 0.3267901, 0.47070992, 0.16493955, 0.8751768],
    [0.072277926, 0.61777425, 0.41861197, 0.30265653, 0.7986402, 0.3239637, 0.75269574, 0.17242455, 0.01895543, 0.5124663, 0.59209484, 0.33796164, 0.7656568, 0.35979486, 0.164532, 0.85192627],
    [0.33077067, 0.3496145, 0.79393107, 0.34820843, 0.08508753, 0.47641373, 0.23593518, 0.79054934, 0.73827904, 0.7532118, 0.22236909, 0.78232795, 0.5382191, 0.15715897, 0.55649596, 0.12317861],
    [0.21837069, 0.7455676, 0.07003461, 0.6162736, 0.61905116, 0.042929675, 0.98639303, 0.6618752, 0.836061, 0.73150545, 0.74348444, 0.075450204, 0.00040107843, 0.583956, 0.7215287, 0.27178788]
    ]> : tensor<4x16xf32>
  %0 = stablehlo.fft %input, type = RFFT, length = [16] : (tensor<4x16xf32>) -> tensor<4x9xcomplex<f32>>
  %1 = stablehlo.real %0 : (tensor<4x9xcomplex<f32>>) -> tensor<4x9xf32>
  %2 = stablehlo.imag %0 : (tensor<4x9xcomplex<f32>>) -> tensor<4x9xf32>
  check.expect_almost_eq_const(%1, dense<[
    [7.805849, 0.0055119395, -0.17536741, 0.083751544, -0.6955836, -0.24068685, 1.1299946, -0.7598432, 0.2913494],
    [7.0624332, 0.24002784, -0.88601315, 0.89173555, -0.2724042, 0.29204032, -2.060114, -1.2105138, 0.10449672],
    [7.281751, -1.0544317, 0.62424886, -0.752149, -0.11637497, -1.3245198, 0.2672373, 1.5010669, -0.27957582],
    [7.92467, -1.2145746, 1.2072296, -1.0975994, -0.8475568, 1.1891953, -0.33727074, -1.3477826, 0.46597958]
    ]> : tensor<4x9xf32>) : tensor<4x9xf32>
  check.expect_almost_eq_const(%2, dense<[
    [0.0, 0.5374942, -1.2511837, 0.44363666, 1.53016, 1.082557, 1.0001776, 0.96048236, 0.0],
    [0.0, -0.04075122, -0.13784951, 0.24302289, -0.14903009, 0.76350343, 0.049108572, 0.6116628, 0.0],
    [0.0, 0.2808264, -0.7089882, -0.9182679, 0.30786526, 0.34296447, -0.26125002, -0.2704674, 0.0],
    [0.0, -0.4842103, 0.46430632, 0.53410053, -0.47857177, -1.2810267, -1.324499, 0.17526275, 0.0]
    ]> : tensor<4x9xf32>) : tensor<4x9xf32>
  return
}

// 1D IRFFT on the innermost dimension of a 2D tensor. This is the inverse of the @rfft_2d() so should give back the original inputs (within floating point error).
func.func @irfft_2d() {
  %input = util.unfoldable_constant dense<[
    [(7.805849,0.0), (0.0055119395,0.5374942), (-0.17536741,-1.2511837), (0.083751544,0.44363666), (-0.6955836,1.53016), (-0.24068685,1.082557), (1.1299946,1.0001776), (-0.7598432,0.96048236), (0.2913494,0.0)],
    [(7.0624332,0.0), (0.24002784,-0.04075122), (-0.88601315,-0.13784951), (0.89173555,0.24302289), (-0.2724042,-0.14903009), (0.29204032,0.76350343), (-2.060114,0.049108572), (-1.2105138,0.6116628), (0.10449672,0.0)],
    [(7.281751,0.0), (-1.0544317,0.2808264), (0.62424886,-0.7089882), (-0.752149,-0.9182679), (-0.11637497,0.30786526), (-1.3245198,0.34296447), (0.2672373,-0.26125002), (1.5010669,-0.2704674), (-0.27957582,0.0)],
    [(7.92467,0.0), (-1.2145746,-0.4842103), (1.2072296,0.46430632), (-1.0975994,0.53410053), (-0.8475568,-0.47857177), (1.1891953,-1.2810267), (-0.33727074,-1.324499), (-1.3477826,0.17526275), (0.46597958,0.0)]
    ]> : tensor<4x9xcomplex<f32>>
  %0 = stablehlo.fft %input, type = IRFFT, length = [16] : (tensor<4x9xcomplex<f32>>) -> tensor<4x16xf32>
  check.expect_almost_eq_const(%0, dense<[
    [0.42454705, 0.041191384, 0.9155005, 0.69764674, 0.27280703, 0.27244806, 0.45826584, 0.17154607, 0.65236366, 0.32919556, 0.83338547, 0.89933527, 0.32679006, 0.47070992, 0.16493948, 0.8751768],
    [0.072277986, 0.61777425, 0.418612, 0.3026565, 0.7986402, 0.3239637, 0.75269574, 0.17242455, 0.018955506, 0.5124663, 0.5920949, 0.33796164, 0.76565677, 0.3597949, 0.16453207, 0.8519262],
    [0.33077067, 0.34961456, 0.79393107, 0.3482084, 0.08508754, 0.47641373, 0.23593518, 0.7905494, 0.73827904, 0.7532118, 0.22236913, 0.7823279, 0.5382191, 0.15715902, 0.5564959, 0.12317863],
    [0.21837068, 0.74556756, 0.07003468, 0.6162735, 0.6190512, 0.04292965, 0.9863931, 0.6618751, 0.836061, 0.7315054, 0.74348444, 0.07545018, 0.00040110946, 0.58395594, 0.72152877, 0.27178788]
    ]> : tensor<4x16xf32>) : tensor<4x16xf32>
  return
}