Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf16>, %b: tensor<8xf16>) -> tensor<8xf16> {
    %0 = stablehlo.add %a, %b : tensor<8xf16>
    return %0 : tensor<8xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf16>, %b: tensor<16xf16>) -> tensor<16xf16> {
    %0 = stablehlo.add %a, %b : tensor<16xf16>
    return %0 : tensor<16xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf16>, %b: tensor<32xf16>) -> tensor<32xf16> {
    %0 = stablehlo.add %a, %b : tensor<32xf16>
    return %0 : tensor<32xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf16>, %b: tensor<64xf16>) -> tensor<64xf16> {
    %0 = stablehlo.add %a, %b : tensor<64xf16>
    return %0 : tensor<64xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf16>, %b: tensor<4x4xf16>) -> tensor<4x4xf16> {
    %0 = stablehlo.add %a, %b : tensor<4x4xf16>
    return %0 : tensor<4x4xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf16>, %b: tensor<8x8xf16>) -> tensor<8x8xf16> {
    %0 = stablehlo.add %a, %b : tensor<8x8xf16>
    return %0 : tensor<8x8xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf16>, %b: tensor<8x16xf16>) -> tensor<8x16xf16> {
    %0 = stablehlo.add %a, %b : tensor<8x16xf16>
    return %0 : tensor<8x16xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf16>, %b: tensor<4x4x4xf16>) -> tensor<4x4x4xf16> {
    %0 = stablehlo.add %a, %b : tensor<4x4x4xf16>
    return %0 : tensor<4x4x4xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f16 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf16>, %b: tensor<2x8x8xf16>) -> tensor<2x8x8xf16> {
    %0 = stablehlo.add %a, %b : tensor<2x8x8xf16>
    return %0 : tensor<2x8x8xf16>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf32>, %b: tensor<8xf32>) -> tensor<8xf32> {
    %0 = stablehlo.add %a, %b : tensor<8xf32>
    return %0 : tensor<8xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {
    %0 = stablehlo.add %a, %b : tensor<16xf32>
    return %0 : tensor<16xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf32>, %b: tensor<32xf32>) -> tensor<32xf32> {
    %0 = stablehlo.add %a, %b : tensor<32xf32>
    return %0 : tensor<32xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf32>, %b: tensor<64xf32>) -> tensor<64xf32> {
    %0 = stablehlo.add %a, %b : tensor<64xf32>
    return %0 : tensor<64xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf32>, %b: tensor<4x4xf32>) -> tensor<4x4xf32> {
    %0 = stablehlo.add %a, %b : tensor<4x4xf32>
    return %0 : tensor<4x4xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf32>, %b: tensor<8x8xf32>) -> tensor<8x8xf32> {
    %0 = stablehlo.add %a, %b : tensor<8x8xf32>
    return %0 : tensor<8x8xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf32>, %b: tensor<8x16xf32>) -> tensor<8x16xf32> {
    %0 = stablehlo.add %a, %b : tensor<8x16xf32>
    return %0 : tensor<8x16xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf32>, %b: tensor<4x4x4xf32>) -> tensor<4x4x4xf32> {
    %0 = stablehlo.add %a, %b : tensor<4x4x4xf32>
    return %0 : tensor<4x4x4xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f32 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf32>, %b: tensor<2x8x8xf32>) -> tensor<2x8x8xf32> {
    %0 = stablehlo.add %a, %b : tensor<2x8x8xf32>
    return %0 : tensor<2x8x8xf32>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf64>, %b: tensor<8xf64>) -> tensor<8xf64> {
    %0 = stablehlo.add %a, %b : tensor<8xf64>
    return %0 : tensor<8xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf64>, %b: tensor<16xf64>) -> tensor<16xf64> {
    %0 = stablehlo.add %a, %b : tensor<16xf64>
    return %0 : tensor<16xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf64>, %b: tensor<32xf64>) -> tensor<32xf64> {
    %0 = stablehlo.add %a, %b : tensor<32xf64>
    return %0 : tensor<32xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf64>, %b: tensor<64xf64>) -> tensor<64xf64> {
    %0 = stablehlo.add %a, %b : tensor<64xf64>
    return %0 : tensor<64xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf64>, %b: tensor<4x4xf64>) -> tensor<4x4xf64> {
    %0 = stablehlo.add %a, %b : tensor<4x4xf64>
    return %0 : tensor<4x4xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf64>, %b: tensor<8x8xf64>) -> tensor<8x8xf64> {
    %0 = stablehlo.add %a, %b : tensor<8x8xf64>
    return %0 : tensor<8x8xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf64>, %b: tensor<8x16xf64>) -> tensor<8x16xf64> {
    %0 = stablehlo.add %a, %b : tensor<8x16xf64>
    return %0 : tensor<8x16xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf64>, %b: tensor<4x4x4xf64>) -> tensor<4x4x4xf64> {
    %0 = stablehlo.add %a, %b : tensor<4x4x4xf64>
    return %0 : tensor<4x4x4xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two f64 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf64>, %b: tensor<2x8x8xf64>) -> tensor<2x8x8xf64> {
    %0 = stablehlo.add %a, %b : tensor<2x8x8xf64>
    return %0 : tensor<2x8x8xf64>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi8>, %b: tensor<8xi8>) -> tensor<8xi8> {
    %0 = stablehlo.add %a, %b : tensor<8xi8>
    return %0 : tensor<8xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi8>, %b: tensor<16xi8>) -> tensor<16xi8> {
    %0 = stablehlo.add %a, %b : tensor<16xi8>
    return %0 : tensor<16xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi8>, %b: tensor<32xi8>) -> tensor<32xi8> {
    %0 = stablehlo.add %a, %b : tensor<32xi8>
    return %0 : tensor<32xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi8>, %b: tensor<64xi8>) -> tensor<64xi8> {
    %0 = stablehlo.add %a, %b : tensor<64xi8>
    return %0 : tensor<64xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi8>, %b: tensor<4x4xi8>) -> tensor<4x4xi8> {
    %0 = stablehlo.add %a, %b : tensor<4x4xi8>
    return %0 : tensor<4x4xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi8>, %b: tensor<8x8xi8>) -> tensor<8x8xi8> {
    %0 = stablehlo.add %a, %b : tensor<8x8xi8>
    return %0 : tensor<8x8xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi8>, %b: tensor<8x16xi8>) -> tensor<8x16xi8> {
    %0 = stablehlo.add %a, %b : tensor<8x16xi8>
    return %0 : tensor<8x16xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi8>, %b: tensor<4x4x4xi8>) -> tensor<4x4x4xi8> {
    %0 = stablehlo.add %a, %b : tensor<4x4x4xi8>
    return %0 : tensor<4x4x4xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i8 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi8>, %b: tensor<2x8x8xi8>) -> tensor<2x8x8xi8> {
    %0 = stablehlo.add %a, %b : tensor<2x8x8xi8>
    return %0 : tensor<2x8x8xi8>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi32>, %b: tensor<8xi32>) -> tensor<8xi32> {
    %0 = stablehlo.add %a, %b : tensor<8xi32>
    return %0 : tensor<8xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi32>, %b: tensor<16xi32>) -> tensor<16xi32> {
    %0 = stablehlo.add %a, %b : tensor<16xi32>
    return %0 : tensor<16xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi32>, %b: tensor<32xi32>) -> tensor<32xi32> {
    %0 = stablehlo.add %a, %b : tensor<32xi32>
    return %0 : tensor<32xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi32>, %b: tensor<64xi32>) -> tensor<64xi32> {
    %0 = stablehlo.add %a, %b : tensor<64xi32>
    return %0 : tensor<64xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi32>, %b: tensor<4x4xi32>) -> tensor<4x4xi32> {
    %0 = stablehlo.add %a, %b : tensor<4x4xi32>
    return %0 : tensor<4x4xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi32>, %b: tensor<8x8xi32>) -> tensor<8x8xi32> {
    %0 = stablehlo.add %a, %b : tensor<8x8xi32>
    return %0 : tensor<8x8xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi32>, %b: tensor<8x16xi32>) -> tensor<8x16xi32> {
    %0 = stablehlo.add %a, %b : tensor<8x16xi32>
    return %0 : tensor<8x16xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi32>, %b: tensor<4x4x4xi32>) -> tensor<4x4x4xi32> {
    %0 = stablehlo.add %a, %b : tensor<4x4x4xi32>
    return %0 : tensor<4x4x4xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i32 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi32>, %b: tensor<2x8x8xi32>) -> tensor<2x8x8xi32> {
    %0 = stablehlo.add %a, %b : tensor<2x8x8xi32>
    return %0 : tensor<2x8x8xi32>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi64>, %b: tensor<8xi64>) -> tensor<8xi64> {
    %0 = stablehlo.add %a, %b : tensor<8xi64>
    return %0 : tensor<8xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi64>, %b: tensor<16xi64>) -> tensor<16xi64> {
    %0 = stablehlo.add %a, %b : tensor<16xi64>
    return %0 : tensor<16xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi64>, %b: tensor<32xi64>) -> tensor<32xi64> {
    %0 = stablehlo.add %a, %b : tensor<32xi64>
    return %0 : tensor<32xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi64>, %b: tensor<64xi64>) -> tensor<64xi64> {
    %0 = stablehlo.add %a, %b : tensor<64xi64>
    return %0 : tensor<64xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi64>, %b: tensor<4x4xi64>) -> tensor<4x4xi64> {
    %0 = stablehlo.add %a, %b : tensor<4x4xi64>
    return %0 : tensor<4x4xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi64>, %b: tensor<8x8xi64>) -> tensor<8x8xi64> {
    %0 = stablehlo.add %a, %b : tensor<8x8xi64>
    return %0 : tensor<8x8xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi64>, %b: tensor<8x16xi64>) -> tensor<8x16xi64> {
    %0 = stablehlo.add %a, %b : tensor<8x16xi64>
    return %0 : tensor<8x16xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi64>, %b: tensor<4x4x4xi64>) -> tensor<4x4x4xi64> {
    %0 = stablehlo.add %a, %b : tensor<4x4x4xi64>
    return %0 : tensor<4x4x4xi64>
  }
}


Write a function that applies stablehlo.add elementwise to two i64 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi64>, %b: tensor<2x8x8xi64>) -> tensor<2x8x8xi64> {
    %0 = stablehlo.add %a, %b : tensor<2x8x8xi64>
    return %0 : tensor<2x8x8xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf16>, %b: tensor<8xf16>) -> tensor<8xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<8xf16>
    return %0 : tensor<8xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf16>, %b: tensor<16xf16>) -> tensor<16xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<16xf16>
    return %0 : tensor<16xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf16>, %b: tensor<32xf16>) -> tensor<32xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<32xf16>
    return %0 : tensor<32xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf16>, %b: tensor<64xf16>) -> tensor<64xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<64xf16>
    return %0 : tensor<64xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf16>, %b: tensor<4x4xf16>) -> tensor<4x4xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4xf16>
    return %0 : tensor<4x4xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf16>, %b: tensor<8x8xf16>) -> tensor<8x8xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<8x8xf16>
    return %0 : tensor<8x8xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf16>, %b: tensor<8x16xf16>) -> tensor<8x16xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<8x16xf16>
    return %0 : tensor<8x16xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf16>, %b: tensor<4x4x4xf16>) -> tensor<4x4x4xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4x4xf16>
    return %0 : tensor<4x4x4xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f16 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf16>, %b: tensor<2x8x8xf16>) -> tensor<2x8x8xf16> {
    %0 = stablehlo.subtract %a, %b : tensor<2x8x8xf16>
    return %0 : tensor<2x8x8xf16>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf32>, %b: tensor<8xf32>) -> tensor<8xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<8xf32>
    return %0 : tensor<8xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<16xf32>
    return %0 : tensor<16xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf32>, %b: tensor<32xf32>) -> tensor<32xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<32xf32>
    return %0 : tensor<32xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf32>, %b: tensor<64xf32>) -> tensor<64xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<64xf32>
    return %0 : tensor<64xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf32>, %b: tensor<4x4xf32>) -> tensor<4x4xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4xf32>
    return %0 : tensor<4x4xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf32>, %b: tensor<8x8xf32>) -> tensor<8x8xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<8x8xf32>
    return %0 : tensor<8x8xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf32>, %b: tensor<8x16xf32>) -> tensor<8x16xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<8x16xf32>
    return %0 : tensor<8x16xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf32>, %b: tensor<4x4x4xf32>) -> tensor<4x4x4xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4x4xf32>
    return %0 : tensor<4x4x4xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f32 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf32>, %b: tensor<2x8x8xf32>) -> tensor<2x8x8xf32> {
    %0 = stablehlo.subtract %a, %b : tensor<2x8x8xf32>
    return %0 : tensor<2x8x8xf32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf64>, %b: tensor<8xf64>) -> tensor<8xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<8xf64>
    return %0 : tensor<8xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf64>, %b: tensor<16xf64>) -> tensor<16xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<16xf64>
    return %0 : tensor<16xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf64>, %b: tensor<32xf64>) -> tensor<32xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<32xf64>
    return %0 : tensor<32xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf64>, %b: tensor<64xf64>) -> tensor<64xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<64xf64>
    return %0 : tensor<64xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf64>, %b: tensor<4x4xf64>) -> tensor<4x4xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4xf64>
    return %0 : tensor<4x4xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf64>, %b: tensor<8x8xf64>) -> tensor<8x8xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<8x8xf64>
    return %0 : tensor<8x8xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf64>, %b: tensor<8x16xf64>) -> tensor<8x16xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<8x16xf64>
    return %0 : tensor<8x16xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf64>, %b: tensor<4x4x4xf64>) -> tensor<4x4x4xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4x4xf64>
    return %0 : tensor<4x4x4xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two f64 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf64>, %b: tensor<2x8x8xf64>) -> tensor<2x8x8xf64> {
    %0 = stablehlo.subtract %a, %b : tensor<2x8x8xf64>
    return %0 : tensor<2x8x8xf64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi8>, %b: tensor<8xi8>) -> tensor<8xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<8xi8>
    return %0 : tensor<8xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi8>, %b: tensor<16xi8>) -> tensor<16xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<16xi8>
    return %0 : tensor<16xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi8>, %b: tensor<32xi8>) -> tensor<32xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<32xi8>
    return %0 : tensor<32xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi8>, %b: tensor<64xi8>) -> tensor<64xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<64xi8>
    return %0 : tensor<64xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi8>, %b: tensor<4x4xi8>) -> tensor<4x4xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4xi8>
    return %0 : tensor<4x4xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi8>, %b: tensor<8x8xi8>) -> tensor<8x8xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<8x8xi8>
    return %0 : tensor<8x8xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi8>, %b: tensor<8x16xi8>) -> tensor<8x16xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<8x16xi8>
    return %0 : tensor<8x16xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi8>, %b: tensor<4x4x4xi8>) -> tensor<4x4x4xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4x4xi8>
    return %0 : tensor<4x4x4xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i8 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi8>, %b: tensor<2x8x8xi8>) -> tensor<2x8x8xi8> {
    %0 = stablehlo.subtract %a, %b : tensor<2x8x8xi8>
    return %0 : tensor<2x8x8xi8>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi32>, %b: tensor<8xi32>) -> tensor<8xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<8xi32>
    return %0 : tensor<8xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi32>, %b: tensor<16xi32>) -> tensor<16xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<16xi32>
    return %0 : tensor<16xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi32>, %b: tensor<32xi32>) -> tensor<32xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<32xi32>
    return %0 : tensor<32xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi32>, %b: tensor<64xi32>) -> tensor<64xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<64xi32>
    return %0 : tensor<64xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi32>, %b: tensor<4x4xi32>) -> tensor<4x4xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4xi32>
    return %0 : tensor<4x4xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi32>, %b: tensor<8x8xi32>) -> tensor<8x8xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<8x8xi32>
    return %0 : tensor<8x8xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi32>, %b: tensor<8x16xi32>) -> tensor<8x16xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<8x16xi32>
    return %0 : tensor<8x16xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi32>, %b: tensor<4x4x4xi32>) -> tensor<4x4x4xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4x4xi32>
    return %0 : tensor<4x4x4xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i32 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi32>, %b: tensor<2x8x8xi32>) -> tensor<2x8x8xi32> {
    %0 = stablehlo.subtract %a, %b : tensor<2x8x8xi32>
    return %0 : tensor<2x8x8xi32>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi64>, %b: tensor<8xi64>) -> tensor<8xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<8xi64>
    return %0 : tensor<8xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi64>, %b: tensor<16xi64>) -> tensor<16xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<16xi64>
    return %0 : tensor<16xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi64>, %b: tensor<32xi64>) -> tensor<32xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<32xi64>
    return %0 : tensor<32xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi64>, %b: tensor<64xi64>) -> tensor<64xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<64xi64>
    return %0 : tensor<64xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi64>, %b: tensor<4x4xi64>) -> tensor<4x4xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4xi64>
    return %0 : tensor<4x4xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi64>, %b: tensor<8x8xi64>) -> tensor<8x8xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<8x8xi64>
    return %0 : tensor<8x8xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi64>, %b: tensor<8x16xi64>) -> tensor<8x16xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<8x16xi64>
    return %0 : tensor<8x16xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi64>, %b: tensor<4x4x4xi64>) -> tensor<4x4x4xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<4x4x4xi64>
    return %0 : tensor<4x4x4xi64>
  }
}


Write a function that applies stablehlo.subtract elementwise to two i64 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi64>, %b: tensor<2x8x8xi64>) -> tensor<2x8x8xi64> {
    %0 = stablehlo.subtract %a, %b : tensor<2x8x8xi64>
    return %0 : tensor<2x8x8xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf16>, %b: tensor<8xf16>) -> tensor<8xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<8xf16>
    return %0 : tensor<8xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf16>, %b: tensor<16xf16>) -> tensor<16xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<16xf16>
    return %0 : tensor<16xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf16>, %b: tensor<32xf16>) -> tensor<32xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<32xf16>
    return %0 : tensor<32xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf16>, %b: tensor<64xf16>) -> tensor<64xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<64xf16>
    return %0 : tensor<64xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf16>, %b: tensor<4x4xf16>) -> tensor<4x4xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4xf16>
    return %0 : tensor<4x4xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf16>, %b: tensor<8x8xf16>) -> tensor<8x8xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<8x8xf16>
    return %0 : tensor<8x8xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf16>, %b: tensor<8x16xf16>) -> tensor<8x16xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<8x16xf16>
    return %0 : tensor<8x16xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf16>, %b: tensor<4x4x4xf16>) -> tensor<4x4x4xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4x4xf16>
    return %0 : tensor<4x4x4xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f16 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf16>, %b: tensor<2x8x8xf16>) -> tensor<2x8x8xf16> {
    %0 = stablehlo.multiply %a, %b : tensor<2x8x8xf16>
    return %0 : tensor<2x8x8xf16>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf32>, %b: tensor<8xf32>) -> tensor<8xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<8xf32>
    return %0 : tensor<8xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<16xf32>
    return %0 : tensor<16xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf32>, %b: tensor<32xf32>) -> tensor<32xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<32xf32>
    return %0 : tensor<32xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf32>, %b: tensor<64xf32>) -> tensor<64xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<64xf32>
    return %0 : tensor<64xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf32>, %b: tensor<4x4xf32>) -> tensor<4x4xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4xf32>
    return %0 : tensor<4x4xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf32>, %b: tensor<8x8xf32>) -> tensor<8x8xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<8x8xf32>
    return %0 : tensor<8x8xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf32>, %b: tensor<8x16xf32>) -> tensor<8x16xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<8x16xf32>
    return %0 : tensor<8x16xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf32>, %b: tensor<4x4x4xf32>) -> tensor<4x4x4xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4x4xf32>
    return %0 : tensor<4x4x4xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f32 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf32>, %b: tensor<2x8x8xf32>) -> tensor<2x8x8xf32> {
    %0 = stablehlo.multiply %a, %b : tensor<2x8x8xf32>
    return %0 : tensor<2x8x8xf32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf64>, %b: tensor<8xf64>) -> tensor<8xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<8xf64>
    return %0 : tensor<8xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf64>, %b: tensor<16xf64>) -> tensor<16xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<16xf64>
    return %0 : tensor<16xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf64>, %b: tensor<32xf64>) -> tensor<32xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<32xf64>
    return %0 : tensor<32xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf64>, %b: tensor<64xf64>) -> tensor<64xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<64xf64>
    return %0 : tensor<64xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf64>, %b: tensor<4x4xf64>) -> tensor<4x4xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4xf64>
    return %0 : tensor<4x4xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf64>, %b: tensor<8x8xf64>) -> tensor<8x8xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<8x8xf64>
    return %0 : tensor<8x8xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf64>, %b: tensor<8x16xf64>) -> tensor<8x16xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<8x16xf64>
    return %0 : tensor<8x16xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf64>, %b: tensor<4x4x4xf64>) -> tensor<4x4x4xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4x4xf64>
    return %0 : tensor<4x4x4xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two f64 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf64>, %b: tensor<2x8x8xf64>) -> tensor<2x8x8xf64> {
    %0 = stablehlo.multiply %a, %b : tensor<2x8x8xf64>
    return %0 : tensor<2x8x8xf64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi8>, %b: tensor<8xi8>) -> tensor<8xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<8xi8>
    return %0 : tensor<8xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi8>, %b: tensor<16xi8>) -> tensor<16xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<16xi8>
    return %0 : tensor<16xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi8>, %b: tensor<32xi8>) -> tensor<32xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<32xi8>
    return %0 : tensor<32xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi8>, %b: tensor<64xi8>) -> tensor<64xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<64xi8>
    return %0 : tensor<64xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi8>, %b: tensor<4x4xi8>) -> tensor<4x4xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4xi8>
    return %0 : tensor<4x4xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi8>, %b: tensor<8x8xi8>) -> tensor<8x8xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<8x8xi8>
    return %0 : tensor<8x8xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi8>, %b: tensor<8x16xi8>) -> tensor<8x16xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<8x16xi8>
    return %0 : tensor<8x16xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi8>, %b: tensor<4x4x4xi8>) -> tensor<4x4x4xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4x4xi8>
    return %0 : tensor<4x4x4xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i8 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi8>, %b: tensor<2x8x8xi8>) -> tensor<2x8x8xi8> {
    %0 = stablehlo.multiply %a, %b : tensor<2x8x8xi8>
    return %0 : tensor<2x8x8xi8>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi32>, %b: tensor<8xi32>) -> tensor<8xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<8xi32>
    return %0 : tensor<8xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi32>, %b: tensor<16xi32>) -> tensor<16xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<16xi32>
    return %0 : tensor<16xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi32>, %b: tensor<32xi32>) -> tensor<32xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<32xi32>
    return %0 : tensor<32xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi32>, %b: tensor<64xi32>) -> tensor<64xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<64xi32>
    return %0 : tensor<64xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi32>, %b: tensor<4x4xi32>) -> tensor<4x4xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4xi32>
    return %0 : tensor<4x4xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi32>, %b: tensor<8x8xi32>) -> tensor<8x8xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<8x8xi32>
    return %0 : tensor<8x8xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi32>, %b: tensor<8x16xi32>) -> tensor<8x16xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<8x16xi32>
    return %0 : tensor<8x16xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi32>, %b: tensor<4x4x4xi32>) -> tensor<4x4x4xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4x4xi32>
    return %0 : tensor<4x4x4xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i32 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi32>, %b: tensor<2x8x8xi32>) -> tensor<2x8x8xi32> {
    %0 = stablehlo.multiply %a, %b : tensor<2x8x8xi32>
    return %0 : tensor<2x8x8xi32>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xi64>, %b: tensor<8xi64>) -> tensor<8xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<8xi64>
    return %0 : tensor<8xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xi64>, %b: tensor<16xi64>) -> tensor<16xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<16xi64>
    return %0 : tensor<16xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xi64>, %b: tensor<32xi64>) -> tensor<32xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<32xi64>
    return %0 : tensor<32xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xi64>, %b: tensor<64xi64>) -> tensor<64xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<64xi64>
    return %0 : tensor<64xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xi64>, %b: tensor<4x4xi64>) -> tensor<4x4xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4xi64>
    return %0 : tensor<4x4xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xi64>, %b: tensor<8x8xi64>) -> tensor<8x8xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<8x8xi64>
    return %0 : tensor<8x8xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xi64>, %b: tensor<8x16xi64>) -> tensor<8x16xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<8x16xi64>
    return %0 : tensor<8x16xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xi64>, %b: tensor<4x4x4xi64>) -> tensor<4x4x4xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<4x4x4xi64>
    return %0 : tensor<4x4x4xi64>
  }
}


Write a function that applies stablehlo.multiply elementwise to two i64 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xi64>, %b: tensor<2x8x8xi64>) -> tensor<2x8x8xi64> {
    %0 = stablehlo.multiply %a, %b : tensor<2x8x8xi64>
    return %0 : tensor<2x8x8xi64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf32>, %b: tensor<8xf32>) -> tensor<8xf32> {
    %0 = stablehlo.divide %a, %b : tensor<8xf32>
    return %0 : tensor<8xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {
    %0 = stablehlo.divide %a, %b : tensor<16xf32>
    return %0 : tensor<16xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf32>, %b: tensor<32xf32>) -> tensor<32xf32> {
    %0 = stablehlo.divide %a, %b : tensor<32xf32>
    return %0 : tensor<32xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf32>, %b: tensor<64xf32>) -> tensor<64xf32> {
    %0 = stablehlo.divide %a, %b : tensor<64xf32>
    return %0 : tensor<64xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf32>, %b: tensor<4x4xf32>) -> tensor<4x4xf32> {
    %0 = stablehlo.divide %a, %b : tensor<4x4xf32>
    return %0 : tensor<4x4xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf32>, %b: tensor<8x8xf32>) -> tensor<8x8xf32> {
    %0 = stablehlo.divide %a, %b : tensor<8x8xf32>
    return %0 : tensor<8x8xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf32>, %b: tensor<8x16xf32>) -> tensor<8x16xf32> {
    %0 = stablehlo.divide %a, %b : tensor<8x16xf32>
    return %0 : tensor<8x16xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf32>, %b: tensor<4x4x4xf32>) -> tensor<4x4x4xf32> {
    %0 = stablehlo.divide %a, %b : tensor<4x4x4xf32>
    return %0 : tensor<4x4x4xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f32 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf32>, %b: tensor<2x8x8xf32>) -> tensor<2x8x8xf32> {
    %0 = stablehlo.divide %a, %b : tensor<2x8x8xf32>
    return %0 : tensor<2x8x8xf32>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf16>, %b: tensor<8xf16>) -> tensor<8xf16> {
    %0 = stablehlo.divide %a, %b : tensor<8xf16>
    return %0 : tensor<8xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf16>, %b: tensor<16xf16>) -> tensor<16xf16> {
    %0 = stablehlo.divide %a, %b : tensor<16xf16>
    return %0 : tensor<16xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf16>, %b: tensor<32xf16>) -> tensor<32xf16> {
    %0 = stablehlo.divide %a, %b : tensor<32xf16>
    return %0 : tensor<32xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf16>, %b: tensor<64xf16>) -> tensor<64xf16> {
    %0 = stablehlo.divide %a, %b : tensor<64xf16>
    return %0 : tensor<64xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf16>, %b: tensor<4x4xf16>) -> tensor<4x4xf16> {
    %0 = stablehlo.divide %a, %b : tensor<4x4xf16>
    return %0 : tensor<4x4xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf16>, %b: tensor<8x8xf16>) -> tensor<8x8xf16> {
    %0 = stablehlo.divide %a, %b : tensor<8x8xf16>
    return %0 : tensor<8x8xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf16>, %b: tensor<8x16xf16>) -> tensor<8x16xf16> {
    %0 = stablehlo.divide %a, %b : tensor<8x16xf16>
    return %0 : tensor<8x16xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf16>, %b: tensor<4x4x4xf16>) -> tensor<4x4x4xf16> {
    %0 = stablehlo.divide %a, %b : tensor<4x4x4xf16>
    return %0 : tensor<4x4x4xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f16 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf16>, %b: tensor<2x8x8xf16>) -> tensor<2x8x8xf16> {
    %0 = stablehlo.divide %a, %b : tensor<2x8x8xf16>
    return %0 : tensor<2x8x8xf16>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf64>, %b: tensor<8xf64>) -> tensor<8xf64> {
    %0 = stablehlo.divide %a, %b : tensor<8xf64>
    return %0 : tensor<8xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf64>, %b: tensor<16xf64>) -> tensor<16xf64> {
    %0 = stablehlo.divide %a, %b : tensor<16xf64>
    return %0 : tensor<16xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf64>, %b: tensor<32xf64>) -> tensor<32xf64> {
    %0 = stablehlo.divide %a, %b : tensor<32xf64>
    return %0 : tensor<32xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf64>, %b: tensor<64xf64>) -> tensor<64xf64> {
    %0 = stablehlo.divide %a, %b : tensor<64xf64>
    return %0 : tensor<64xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf64>, %b: tensor<4x4xf64>) -> tensor<4x4xf64> {
    %0 = stablehlo.divide %a, %b : tensor<4x4xf64>
    return %0 : tensor<4x4xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf64>, %b: tensor<8x8xf64>) -> tensor<8x8xf64> {
    %0 = stablehlo.divide %a, %b : tensor<8x8xf64>
    return %0 : tensor<8x8xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf64>, %b: tensor<8x16xf64>) -> tensor<8x16xf64> {
    %0 = stablehlo.divide %a, %b : tensor<8x16xf64>
    return %0 : tensor<8x16xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf64>, %b: tensor<4x4x4xf64>) -> tensor<4x4x4xf64> {
    %0 = stablehlo.divide %a, %b : tensor<4x4x4xf64>
    return %0 : tensor<4x4x4xf64>
  }
}


Write a function that applies stablehlo.divide elementwise to two f64 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf64>, %b: tensor<2x8x8xf64>) -> tensor<2x8x8xf64> {
    %0 = stablehlo.divide %a, %b : tensor<2x8x8xf64>
    return %0 : tensor<2x8x8xf64>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf16>, %b: tensor<8xf16>) -> tensor<8xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<8xf16>
    return %0 : tensor<8xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf16>, %b: tensor<16xf16>) -> tensor<16xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<16xf16>
    return %0 : tensor<16xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 32.

module {
  func.func @f(%a: tensor<32xf16>, %b: tensor<32xf16>) -> tensor<32xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<32xf16>
    return %0 : tensor<32xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 64.

module {
  func.func @f(%a: tensor<64xf16>, %b: tensor<64xf16>) -> tensor<64xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<64xf16>
    return %0 : tensor<64xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 4x4.

module {
  func.func @f(%a: tensor<4x4xf16>, %b: tensor<4x4xf16>) -> tensor<4x4xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<4x4xf16>
    return %0 : tensor<4x4xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 8x8.

module {
  func.func @f(%a: tensor<8x8xf16>, %b: tensor<8x8xf16>) -> tensor<8x8xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<8x8xf16>
    return %0 : tensor<8x8xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 8x16.

module {
  func.func @f(%a: tensor<8x16xf16>, %b: tensor<8x16xf16>) -> tensor<8x16xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<8x16xf16>
    return %0 : tensor<8x16xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 4x4x4.

module {
  func.func @f(%a: tensor<4x4x4xf16>, %b: tensor<4x4x4xf16>) -> tensor<4x4x4xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<4x4x4xf16>
    return %0 : tensor<4x4x4xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f16 tensors of shape 2x8x8.

module {
  func.func @f(%a: tensor<2x8x8xf16>, %b: tensor<2x8x8xf16>) -> tensor<2x8x8xf16> {
    %0 = stablehlo.maximum %a, %b : tensor<2x8x8xf16>
    return %0 : tensor<2x8x8xf16>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f32 tensors of shape 8.

module {
  func.func @f(%a: tensor<8xf32>, %b: tensor<8xf32>) -> tensor<8xf32> {
    %0 = stablehlo.maximum %a, %b : tensor<8xf32>
    return %0 : tensor<8xf32>
  }
}


Write a function that applies stablehlo.maximum elementwise to two f32 tensors of shape 16.

module {
  func.func @f(%a: tensor<16xf32>, %b: tensor<16xf32>) -> tensor<16xf32> {
    %0 = stablehlo.maximum %a, %b : tensor<16xf32>
    return %0 : tensor<16xf32>
  }
}