parakeet-rs 0.4.2

// Generated by scripts/generate_burn.py from encoder_model.onnx with burn-onnx 0.22.0. Do not edit.
extern crate alloc;
use burn::prelude::*;
use burn::nn::LayerNorm;
use burn::nn::LayerNormConfig;
use burn::nn::Linear;
use burn::nn::LinearConfig;
use burn::nn::PaddingConfig1d;
use burn::nn::PaddingConfig2d;
use burn::nn::conv::Conv1d;
use burn::nn::conv::Conv1dConfig;
use burn::nn::conv::Conv2d;
use burn::nn::conv::Conv2dConfig;


#[derive(Module, Debug)]
pub struct Submodule1 {
    conv2d1: Conv2d,
    conv2d2: Conv2d,
    conv2d3: Conv2d,
    conv2d4: Conv2d,
    conv2d5: Conv2d,
    linear1: Linear,
    constant13: burn::module::Param<Tensor<2>>,
    layernormalization1: LayerNorm,
    linear2: Linear,
    linear3: Linear,
    constant1705: burn::module::Param<Tensor<1>>,
    layernormalization2: LayerNorm,
    linear4: Linear,
    linear5: Linear,
    linear6: Linear,
    constant28: burn::module::Param<Tensor<1>>,
    constant29: burn::module::Param<Tensor<4>>,
    linear7: Linear,
    constant1719: burn::module::Param<Tensor<1>>,
    linear8: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule1 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let conv2d1 = Conv2dConfig::new([1, 256], [3, 3])
            .with_stride([2, 2])
            .with_padding(PaddingConfig2d::Explicit(1, 1, 1, 1))
            .with_dilation([1, 1])
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv2d2 = Conv2dConfig::new([256, 256], [3, 3])
            .with_stride([2, 2])
            .with_padding(PaddingConfig2d::Explicit(1, 1, 1, 1))
            .with_dilation([1, 1])
            .with_groups(256)
            .with_bias(true)
            .init(device);
        let conv2d3 = Conv2dConfig::new([256, 256], [1, 1])
            .with_stride([1, 1])
            .with_padding(PaddingConfig2d::Valid)
            .with_dilation([1, 1])
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv2d4 = Conv2dConfig::new([256, 256], [3, 3])
            .with_stride([2, 2])
            .with_padding(PaddingConfig2d::Explicit(1, 1, 1, 1))
            .with_dilation([1, 1])
            .with_groups(256)
            .with_bias(true)
            .init(device);
        let conv2d5 = Conv2dConfig::new([256, 256], [1, 1])
            .with_stride([1, 1])
            .with_padding(PaddingConfig2d::Valid)
            .with_dilation([1, 1])
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let linear1 = LinearConfig::new(4096, 1280).with_bias(true).init(device);
        let constant13: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([640, 1], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [640, 1].into(),
        );
        let layernormalization1 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear2 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear3 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1705: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization2 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear4 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear5 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear6 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant28: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant29: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear7 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1719: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear8 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            conv2d1,
            conv2d2,
            conv2d3,
            conv2d4,
            conv2d5,
            linear1,
            constant13,
            layernormalization1,
            linear2,
            linear3,
            constant1705,
            layernormalization2,
            linear4,
            linear5,
            linear6,
            constant28,
            constant29,
            linear7,
            constant1719,
            linear8,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, input_features: Tensor<3>) -> (Tensor<3>, Tensor<3>) {
        let unsqueeze1_out1: Tensor<4> = input_features.unsqueeze_dims::<4>(&[1]);
        let conv2d1_out1 = self.conv2d1.forward(unsqueeze1_out1);
        let relu1_out1 = burn::tensor::activation::relu(conv2d1_out1);
        let conv2d2_out1 = self.conv2d2.forward(relu1_out1);
        let conv2d3_out1 = self.conv2d3.forward(conv2d2_out1);
        let relu2_out1 = burn::tensor::activation::relu(conv2d3_out1);
        let conv2d4_out1 = self.conv2d4.forward(relu2_out1);
        let conv2d5_out1 = self.conv2d5.forward(conv2d4_out1);
        let relu3_out1 = burn::tensor::activation::relu(conv2d5_out1);
        let transpose1_out1 = relu3_out1.permute([0, 2, 1, 3]);
        let reshape1_out1 = transpose1_out1.reshape([0, 0, -1]);
        let linear1_out1 = self.linear1.forward(reshape1_out1);
        let shape1_out1: [i64; 3] = {
            let axes = &linear1_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather1_out1 = shape1_out1[1] as i64;
        let constant1699_out1 = 1i64;
        let sub1_out1 = gather1_out1 - constant1699_out1;
        let neg1_out1 = -gather1_out1;
        let range1_out1 = {
            let delta = -1i64;
            assert!(delta != 0);
            let n = (((neg1_out1 as i128 - sub1_out1 as i128) as f64) / delta as f64)
                .ceil()
                .max(0.0) as i64;
            Tensor::arange(0..n, &self.device)
                .cast(burn::tensor::DType::I64)
                .mul_scalar(delta)
                .add_scalar(sub1_out1)
        };
        let cast1_out1 = range1_out1.float().cast(burn::tensor::DType::F32);
        let unsqueeze2_out1: Tensor<2> = cast1_out1.unsqueeze_dims::<2>(&[0]);
        let constant13_out1 = self.constant13.val();
        let matmul2_out1 = constant13_out1.matmul(unsqueeze2_out1);
        let transpose2_out1 = matmul2_out1.permute([1, 0]);
        let sin1_out1 = transpose2_out1.clone().sin();
        let cos1_out1 = transpose2_out1.cos();
        let unsqueeze3_out1: Tensor<3> = sin1_out1.unsqueeze_dims::<3>(&[-1]);
        let unsqueeze4_out1: Tensor<3> = cos1_out1.unsqueeze_dims::<3>(&[-1]);
        let concat1_out1 = burn::tensor::Tensor::cat(
            [unsqueeze3_out1, unsqueeze4_out1].into(),
            2,
        );
        let reshape2_out1 = concat1_out1.reshape([1, -1, 1280]);
        let layernormalization1_out1 = {
            let dtype = linear1_out1.clone().dtype();
            self.layernormalization1
                .forward(linear1_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear2_out1 = self.linear2.forward(layernormalization1_out1);
        let sigmoid1_out1 = burn::tensor::activation::sigmoid(linear2_out1.clone());
        let mul1_out1 = linear2_out1.mul(sigmoid1_out1);
        let linear3_out1 = self.linear3.forward(mul1_out1);
        let constant1705_out1 = self.constant1705.val();
        let mul2_out1 = linear3_out1
            .mul((constant1705_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add1_out1 = linear1_out1.add(mul2_out1);
        let layernormalization2_out1 = {
            let dtype = add1_out1.clone().dtype();
            self.layernormalization2
                .forward(add1_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear4_out1 = self.linear4.forward(layernormalization2_out1.clone());
        let linear5_out1 = self.linear5.forward(layernormalization2_out1.clone());
        let linear6_out1 = self.linear6.forward(layernormalization2_out1);
        let constant28_out1 = self.constant28.val();
        let add2_out1 = linear4_out1
            .clone()
            .add((constant28_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape3_out1 = linear4_out1.reshape([0, -1, 8, 160]);
        let transpose3_out1 = reshape3_out1.permute([0, 2, 1, 3]);
        let constant29_out1 = self.constant29.val();
        let add3_out1 = transpose3_out1.clone().add(constant29_out1);
        let linear7_out1 = self.linear7.forward(reshape2_out1.clone());
        let reshape4_out1 = linear7_out1.reshape([0, -1, 8, 160]);
        let transpose4_out1 = reshape4_out1.permute([0, 2, 3, 1]);
        let matmul9_out1 = add3_out1.matmul(transpose4_out1);
        let pad1_out1 = matmul9_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape2_out1: [i64; 4] = {
            let axes = &transpose3_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather2_out1 = shape2_out1[2] as i64;
        let unsqueeze5_out1 = [gather2_out1 as i64];
        let constant1711_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat2_out1: [i64; 4usize] = [&constant1711_out1[..], &unsqueeze5_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape5_out1 = pad1_out1.reshape(concat2_out1);
        let slice1_out1 = reshape5_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1715_out1: [i64; 2] = [0i64, 0i64];
        let constant1716_out1: [i64; 1] = [-1i64];
        let concat3_out1: [i64; 4usize] = [
            &constant1715_out1[..],
            &unsqueeze5_out1[..],
            &constant1716_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape6_out1 = slice1_out1.reshape(concat3_out1);
        let slice2_out1 = reshape6_out1.slice(s![.., .., .., 0..unsqueeze5_out1[0]]);
        let constant1719_out1 = self.constant1719.val();
        let mul3_out1 = slice2_out1
            .mul((constant1719_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention1_out1,) = {
            let q = add2_out1;
            let k = linear5_out1;
            let v = linear6_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul3_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention1_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention1_out1 = {
                let dims = attention1_out1.dims();
                attention1_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention1_out1 = attention1_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention1_out1,)
        };
        let linear8_out1 = self.linear8.forward(attention1_out1);
        let add4_out1 = add1_out1.add(linear8_out1);
        (add4_out1, reshape2_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule2 {
    layernormalization3: LayerNorm,
    conv1d1: Conv1d,
    conv1d2: Conv1d,
    conv1d3: Conv1d,
    layernormalization4: LayerNorm,
    linear9: Linear,
    linear10: Linear,
    constant1721: burn::module::Param<Tensor<1>>,
    layernormalization5: LayerNorm,
    layernormalization6: LayerNorm,
    linear11: Linear,
    linear12: Linear,
    constant1722: burn::module::Param<Tensor<1>>,
    layernormalization7: LayerNorm,
    linear13: Linear,
    linear14: Linear,
    linear15: Linear,
    constant63: burn::module::Param<Tensor<1>>,
    constant64: burn::module::Param<Tensor<4>>,
    linear16: Linear,
    constant1736: burn::module::Param<Tensor<1>>,
    linear17: Linear,
    layernormalization8: LayerNorm,
    conv1d4: Conv1d,
    conv1d5: Conv1d,
    conv1d6: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule2 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization3 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d1 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d2 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d3 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization4 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear9 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear10 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1721: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization5 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization6 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear11 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear12 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1722: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization7 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear13 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear14 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear15 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant63: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant64: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear16 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1736: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear17 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization8 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d4 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d5 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d6 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization3,
            conv1d1,
            conv1d2,
            conv1d3,
            layernormalization4,
            linear9,
            linear10,
            constant1721,
            layernormalization5,
            layernormalization6,
            linear11,
            linear12,
            constant1722,
            layernormalization7,
            linear13,
            linear14,
            linear15,
            constant63,
            constant64,
            linear16,
            constant1736,
            linear17,
            layernormalization8,
            conv1d4,
            conv1d5,
            conv1d6,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add4_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization3_out1 = {
            let dtype = add4_out1.clone().dtype();
            self.layernormalization3
                .forward(add4_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose5_out1 = layernormalization3_out1.permute([0, 2, 1]);
        let conv1d1_out1 = self.conv1d1.forward(transpose5_out1);
        let split_tensors = conv1d1_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split1_out1, split1_out2] = split_tensors.try_into().unwrap();
        let sigmoid2_out1 = burn::tensor::activation::sigmoid(split1_out2);
        let mul4_out1 = split1_out1.mul(sigmoid2_out1);
        let conv1d2_out1 = self.conv1d2.forward(mul4_out1);
        let sigmoid3_out1 = burn::tensor::activation::sigmoid(conv1d2_out1.clone());
        let mul5_out1 = conv1d2_out1.mul(sigmoid3_out1);
        let conv1d3_out1 = self.conv1d3.forward(mul5_out1);
        let transpose6_out1 = conv1d3_out1.permute([0, 2, 1]);
        let add5_out1 = add4_out1.add(transpose6_out1);
        let layernormalization4_out1 = {
            let dtype = add5_out1.clone().dtype();
            self.layernormalization4
                .forward(add5_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear9_out1 = self.linear9.forward(layernormalization4_out1);
        let sigmoid4_out1 = burn::tensor::activation::sigmoid(linear9_out1.clone());
        let mul6_out1 = linear9_out1.mul(sigmoid4_out1);
        let linear10_out1 = self.linear10.forward(mul6_out1);
        let constant1721_out1 = self.constant1721.val();
        let mul7_out1 = linear10_out1
            .mul((constant1721_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add6_out1 = add5_out1.add(mul7_out1);
        let layernormalization5_out1 = {
            let dtype = add6_out1.dtype();
            self.layernormalization5
                .forward(add6_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization6_out1 = {
            let dtype = layernormalization5_out1.clone().dtype();
            self.layernormalization6
                .forward(layernormalization5_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear11_out1 = self.linear11.forward(layernormalization6_out1);
        let sigmoid5_out1 = burn::tensor::activation::sigmoid(linear11_out1.clone());
        let mul8_out1 = linear11_out1.mul(sigmoid5_out1);
        let linear12_out1 = self.linear12.forward(mul8_out1);
        let constant1722_out1 = self.constant1722.val();
        let mul9_out1 = linear12_out1
            .mul((constant1722_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add7_out1 = layernormalization5_out1.add(mul9_out1);
        let layernormalization7_out1 = {
            let dtype = add7_out1.clone().dtype();
            self.layernormalization7
                .forward(add7_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear13_out1 = self.linear13.forward(layernormalization7_out1.clone());
        let linear14_out1 = self.linear14.forward(layernormalization7_out1.clone());
        let linear15_out1 = self.linear15.forward(layernormalization7_out1);
        let constant63_out1 = self.constant63.val();
        let add8_out1 = linear13_out1
            .clone()
            .add((constant63_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape7_out1 = linear13_out1.reshape([0, -1, 8, 160]);
        let transpose7_out1 = reshape7_out1.permute([0, 2, 1, 3]);
        let constant64_out1 = self.constant64.val();
        let add9_out1 = transpose7_out1.clone().add(constant64_out1);
        let linear16_out1 = self.linear16.forward(reshape2_out1);
        let reshape8_out1 = linear16_out1.reshape([0, -1, 8, 160]);
        let transpose8_out1 = reshape8_out1.permute([0, 2, 3, 1]);
        let matmul19_out1 = add9_out1.matmul(transpose8_out1);
        let pad2_out1 = matmul19_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape3_out1: [i64; 4] = {
            let axes = &transpose7_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather3_out1 = shape3_out1[2] as i64;
        let unsqueeze6_out1 = [gather3_out1 as i64];
        let constant1728_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat4_out1: [i64; 4usize] = [&constant1728_out1[..], &unsqueeze6_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape9_out1 = pad2_out1.reshape(concat4_out1);
        let slice3_out1 = reshape9_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1732_out1: [i64; 2] = [0i64, 0i64];
        let constant1733_out1: [i64; 1] = [-1i64];
        let concat5_out1: [i64; 4usize] = [
            &constant1732_out1[..],
            &unsqueeze6_out1[..],
            &constant1733_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape10_out1 = slice3_out1.reshape(concat5_out1);
        let slice4_out1 = reshape10_out1.slice(s![.., .., .., 0..unsqueeze6_out1[0]]);
        let constant1736_out1 = self.constant1736.val();
        let mul10_out1 = slice4_out1
            .mul((constant1736_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention2_out1,) = {
            let q = add8_out1;
            let k = linear14_out1;
            let v = linear15_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul10_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention2_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention2_out1 = {
                let dims = attention2_out1.dims();
                attention2_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention2_out1 = attention2_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention2_out1,)
        };
        let linear17_out1 = self.linear17.forward(attention2_out1);
        let add10_out1 = add7_out1.add(linear17_out1);
        let layernormalization8_out1 = {
            let dtype = add10_out1.clone().dtype();
            self.layernormalization8
                .forward(add10_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose9_out1 = layernormalization8_out1.permute([0, 2, 1]);
        let conv1d4_out1 = self.conv1d4.forward(transpose9_out1);
        let split_tensors = conv1d4_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split2_out1, split2_out2] = split_tensors.try_into().unwrap();
        let sigmoid6_out1 = burn::tensor::activation::sigmoid(split2_out2);
        let mul11_out1 = split2_out1.mul(sigmoid6_out1);
        let conv1d5_out1 = self.conv1d5.forward(mul11_out1);
        let sigmoid7_out1 = burn::tensor::activation::sigmoid(conv1d5_out1.clone());
        let mul12_out1 = conv1d5_out1.mul(sigmoid7_out1);
        let conv1d6_out1 = self.conv1d6.forward(mul12_out1);
        let transpose10_out1 = conv1d6_out1.permute([0, 2, 1]);
        let add11_out1 = add10_out1.add(transpose10_out1);
        add11_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule3 {
    layernormalization9: LayerNorm,
    linear18: Linear,
    linear19: Linear,
    constant1738: burn::module::Param<Tensor<1>>,
    layernormalization10: LayerNorm,
    layernormalization11: LayerNorm,
    linear20: Linear,
    linear21: Linear,
    constant1739: burn::module::Param<Tensor<1>>,
    layernormalization12: LayerNorm,
    linear22: Linear,
    linear23: Linear,
    linear24: Linear,
    constant98: burn::module::Param<Tensor<1>>,
    constant99: burn::module::Param<Tensor<4>>,
    linear25: Linear,
    constant1753: burn::module::Param<Tensor<1>>,
    linear26: Linear,
    layernormalization13: LayerNorm,
    conv1d7: Conv1d,
    conv1d8: Conv1d,
    conv1d9: Conv1d,
    layernormalization14: LayerNorm,
    linear27: Linear,
    linear28: Linear,
    constant1755: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule3 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization9 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear18 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear19 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1738: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization10 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization11 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear20 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear21 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1739: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization12 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear22 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear23 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear24 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant98: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant99: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear25 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1753: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear26 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization13 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d7 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d8 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d9 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization14 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear27 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear28 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1755: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization9,
            linear18,
            linear19,
            constant1738,
            layernormalization10,
            layernormalization11,
            linear20,
            linear21,
            constant1739,
            layernormalization12,
            linear22,
            linear23,
            linear24,
            constant98,
            constant99,
            linear25,
            constant1753,
            linear26,
            layernormalization13,
            conv1d7,
            conv1d8,
            conv1d9,
            layernormalization14,
            linear27,
            linear28,
            constant1755,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add11_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization9_out1 = {
            let dtype = add11_out1.clone().dtype();
            self.layernormalization9
                .forward(add11_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear18_out1 = self.linear18.forward(layernormalization9_out1);
        let sigmoid8_out1 = burn::tensor::activation::sigmoid(linear18_out1.clone());
        let mul13_out1 = linear18_out1.mul(sigmoid8_out1);
        let linear19_out1 = self.linear19.forward(mul13_out1);
        let constant1738_out1 = self.constant1738.val();
        let mul14_out1 = linear19_out1
            .mul((constant1738_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add12_out1 = add11_out1.add(mul14_out1);
        let layernormalization10_out1 = {
            let dtype = add12_out1.dtype();
            self.layernormalization10
                .forward(add12_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization11_out1 = {
            let dtype = layernormalization10_out1.clone().dtype();
            self.layernormalization11
                .forward(
                    layernormalization10_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear20_out1 = self.linear20.forward(layernormalization11_out1);
        let sigmoid9_out1 = burn::tensor::activation::sigmoid(linear20_out1.clone());
        let mul15_out1 = linear20_out1.mul(sigmoid9_out1);
        let linear21_out1 = self.linear21.forward(mul15_out1);
        let constant1739_out1 = self.constant1739.val();
        let mul16_out1 = linear21_out1
            .mul((constant1739_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add13_out1 = layernormalization10_out1.add(mul16_out1);
        let layernormalization12_out1 = {
            let dtype = add13_out1.clone().dtype();
            self.layernormalization12
                .forward(add13_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear22_out1 = self.linear22.forward(layernormalization12_out1.clone());
        let linear23_out1 = self.linear23.forward(layernormalization12_out1.clone());
        let linear24_out1 = self.linear24.forward(layernormalization12_out1);
        let constant98_out1 = self.constant98.val();
        let add14_out1 = linear22_out1
            .clone()
            .add((constant98_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape11_out1 = linear22_out1.reshape([0, -1, 8, 160]);
        let transpose11_out1 = reshape11_out1.permute([0, 2, 1, 3]);
        let constant99_out1 = self.constant99.val();
        let add15_out1 = transpose11_out1.clone().add(constant99_out1);
        let linear25_out1 = self.linear25.forward(reshape2_out1);
        let reshape12_out1 = linear25_out1.reshape([0, -1, 8, 160]);
        let transpose12_out1 = reshape12_out1.permute([0, 2, 3, 1]);
        let matmul29_out1 = add15_out1.matmul(transpose12_out1);
        let pad3_out1 = matmul29_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape4_out1: [i64; 4] = {
            let axes = &transpose11_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather4_out1 = shape4_out1[2] as i64;
        let unsqueeze7_out1 = [gather4_out1 as i64];
        let constant1745_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat6_out1: [i64; 4usize] = [&constant1745_out1[..], &unsqueeze7_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape13_out1 = pad3_out1.reshape(concat6_out1);
        let slice5_out1 = reshape13_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1749_out1: [i64; 2] = [0i64, 0i64];
        let constant1750_out1: [i64; 1] = [-1i64];
        let concat7_out1: [i64; 4usize] = [
            &constant1749_out1[..],
            &unsqueeze7_out1[..],
            &constant1750_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape14_out1 = slice5_out1.reshape(concat7_out1);
        let slice6_out1 = reshape14_out1.slice(s![.., .., .., 0..unsqueeze7_out1[0]]);
        let constant1753_out1 = self.constant1753.val();
        let mul17_out1 = slice6_out1
            .mul((constant1753_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention3_out1,) = {
            let q = add14_out1;
            let k = linear23_out1;
            let v = linear24_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul17_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention3_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention3_out1 = {
                let dims = attention3_out1.dims();
                attention3_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention3_out1 = attention3_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention3_out1,)
        };
        let linear26_out1 = self.linear26.forward(attention3_out1);
        let add16_out1 = add13_out1.add(linear26_out1);
        let layernormalization13_out1 = {
            let dtype = add16_out1.clone().dtype();
            self.layernormalization13
                .forward(add16_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose13_out1 = layernormalization13_out1.permute([0, 2, 1]);
        let conv1d7_out1 = self.conv1d7.forward(transpose13_out1);
        let split_tensors = conv1d7_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split3_out1, split3_out2] = split_tensors.try_into().unwrap();
        let sigmoid10_out1 = burn::tensor::activation::sigmoid(split3_out2);
        let mul18_out1 = split3_out1.mul(sigmoid10_out1);
        let conv1d8_out1 = self.conv1d8.forward(mul18_out1);
        let sigmoid11_out1 = burn::tensor::activation::sigmoid(conv1d8_out1.clone());
        let mul19_out1 = conv1d8_out1.mul(sigmoid11_out1);
        let conv1d9_out1 = self.conv1d9.forward(mul19_out1);
        let transpose14_out1 = conv1d9_out1.permute([0, 2, 1]);
        let add17_out1 = add16_out1.add(transpose14_out1);
        let layernormalization14_out1 = {
            let dtype = add17_out1.clone().dtype();
            self.layernormalization14
                .forward(add17_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear27_out1 = self.linear27.forward(layernormalization14_out1);
        let sigmoid12_out1 = burn::tensor::activation::sigmoid(linear27_out1.clone());
        let mul20_out1 = linear27_out1.mul(sigmoid12_out1);
        let linear28_out1 = self.linear28.forward(mul20_out1);
        let constant1755_out1 = self.constant1755.val();
        let mul21_out1 = linear28_out1
            .mul((constant1755_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add18_out1 = add17_out1.add(mul21_out1);
        add18_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule4 {
    layernormalization15: LayerNorm,
    layernormalization16: LayerNorm,
    linear29: Linear,
    linear30: Linear,
    constant1756: burn::module::Param<Tensor<1>>,
    layernormalization17: LayerNorm,
    linear31: Linear,
    linear32: Linear,
    linear33: Linear,
    constant133: burn::module::Param<Tensor<1>>,
    constant134: burn::module::Param<Tensor<4>>,
    linear34: Linear,
    constant1770: burn::module::Param<Tensor<1>>,
    linear35: Linear,
    layernormalization18: LayerNorm,
    conv1d10: Conv1d,
    conv1d11: Conv1d,
    conv1d12: Conv1d,
    layernormalization19: LayerNorm,
    linear36: Linear,
    linear37: Linear,
    constant1772: burn::module::Param<Tensor<1>>,
    layernormalization20: LayerNorm,
    layernormalization21: LayerNorm,
    linear38: Linear,
    linear39: Linear,
    constant1773: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule4 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization15 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization16 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear29 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear30 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1756: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization17 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear31 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear32 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear33 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant133: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant134: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear34 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1770: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear35 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization18 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d10 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d11 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d12 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization19 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear36 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear37 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1772: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization20 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization21 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear38 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear39 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1773: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization15,
            layernormalization16,
            linear29,
            linear30,
            constant1756,
            layernormalization17,
            linear31,
            linear32,
            linear33,
            constant133,
            constant134,
            linear34,
            constant1770,
            linear35,
            layernormalization18,
            conv1d10,
            conv1d11,
            conv1d12,
            layernormalization19,
            linear36,
            linear37,
            constant1772,
            layernormalization20,
            layernormalization21,
            linear38,
            linear39,
            constant1773,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add18_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization15_out1 = {
            let dtype = add18_out1.dtype();
            self.layernormalization15
                .forward(add18_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization16_out1 = {
            let dtype = layernormalization15_out1.clone().dtype();
            self.layernormalization16
                .forward(
                    layernormalization15_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear29_out1 = self.linear29.forward(layernormalization16_out1);
        let sigmoid13_out1 = burn::tensor::activation::sigmoid(linear29_out1.clone());
        let mul22_out1 = linear29_out1.mul(sigmoid13_out1);
        let linear30_out1 = self.linear30.forward(mul22_out1);
        let constant1756_out1 = self.constant1756.val();
        let mul23_out1 = linear30_out1
            .mul((constant1756_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add19_out1 = layernormalization15_out1.add(mul23_out1);
        let layernormalization17_out1 = {
            let dtype = add19_out1.clone().dtype();
            self.layernormalization17
                .forward(add19_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear31_out1 = self.linear31.forward(layernormalization17_out1.clone());
        let linear32_out1 = self.linear32.forward(layernormalization17_out1.clone());
        let linear33_out1 = self.linear33.forward(layernormalization17_out1);
        let constant133_out1 = self.constant133.val();
        let add20_out1 = linear31_out1
            .clone()
            .add((constant133_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape15_out1 = linear31_out1.reshape([0, -1, 8, 160]);
        let transpose15_out1 = reshape15_out1.permute([0, 2, 1, 3]);
        let constant134_out1 = self.constant134.val();
        let add21_out1 = transpose15_out1.clone().add(constant134_out1);
        let linear34_out1 = self.linear34.forward(reshape2_out1);
        let reshape16_out1 = linear34_out1.reshape([0, -1, 8, 160]);
        let transpose16_out1 = reshape16_out1.permute([0, 2, 3, 1]);
        let matmul39_out1 = add21_out1.matmul(transpose16_out1);
        let pad4_out1 = matmul39_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape5_out1: [i64; 4] = {
            let axes = &transpose15_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather5_out1 = shape5_out1[2] as i64;
        let unsqueeze8_out1 = [gather5_out1 as i64];
        let constant1762_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat8_out1: [i64; 4usize] = [&constant1762_out1[..], &unsqueeze8_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape17_out1 = pad4_out1.reshape(concat8_out1);
        let slice7_out1 = reshape17_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1766_out1: [i64; 2] = [0i64, 0i64];
        let constant1767_out1: [i64; 1] = [-1i64];
        let concat9_out1: [i64; 4usize] = [
            &constant1766_out1[..],
            &unsqueeze8_out1[..],
            &constant1767_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape18_out1 = slice7_out1.reshape(concat9_out1);
        let slice8_out1 = reshape18_out1.slice(s![.., .., .., 0..unsqueeze8_out1[0]]);
        let constant1770_out1 = self.constant1770.val();
        let mul24_out1 = slice8_out1
            .mul((constant1770_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention4_out1,) = {
            let q = add20_out1;
            let k = linear32_out1;
            let v = linear33_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul24_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention4_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention4_out1 = {
                let dims = attention4_out1.dims();
                attention4_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention4_out1 = attention4_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention4_out1,)
        };
        let linear35_out1 = self.linear35.forward(attention4_out1);
        let add22_out1 = add19_out1.add(linear35_out1);
        let layernormalization18_out1 = {
            let dtype = add22_out1.clone().dtype();
            self.layernormalization18
                .forward(add22_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose17_out1 = layernormalization18_out1.permute([0, 2, 1]);
        let conv1d10_out1 = self.conv1d10.forward(transpose17_out1);
        let split_tensors = conv1d10_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split4_out1, split4_out2] = split_tensors.try_into().unwrap();
        let sigmoid14_out1 = burn::tensor::activation::sigmoid(split4_out2);
        let mul25_out1 = split4_out1.mul(sigmoid14_out1);
        let conv1d11_out1 = self.conv1d11.forward(mul25_out1);
        let sigmoid15_out1 = burn::tensor::activation::sigmoid(conv1d11_out1.clone());
        let mul26_out1 = conv1d11_out1.mul(sigmoid15_out1);
        let conv1d12_out1 = self.conv1d12.forward(mul26_out1);
        let transpose18_out1 = conv1d12_out1.permute([0, 2, 1]);
        let add23_out1 = add22_out1.add(transpose18_out1);
        let layernormalization19_out1 = {
            let dtype = add23_out1.clone().dtype();
            self.layernormalization19
                .forward(add23_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear36_out1 = self.linear36.forward(layernormalization19_out1);
        let sigmoid16_out1 = burn::tensor::activation::sigmoid(linear36_out1.clone());
        let mul27_out1 = linear36_out1.mul(sigmoid16_out1);
        let linear37_out1 = self.linear37.forward(mul27_out1);
        let constant1772_out1 = self.constant1772.val();
        let mul28_out1 = linear37_out1
            .mul((constant1772_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add24_out1 = add23_out1.add(mul28_out1);
        let layernormalization20_out1 = {
            let dtype = add24_out1.dtype();
            self.layernormalization20
                .forward(add24_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization21_out1 = {
            let dtype = layernormalization20_out1.clone().dtype();
            self.layernormalization21
                .forward(
                    layernormalization20_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear38_out1 = self.linear38.forward(layernormalization21_out1);
        let sigmoid17_out1 = burn::tensor::activation::sigmoid(linear38_out1.clone());
        let mul29_out1 = linear38_out1.mul(sigmoid17_out1);
        let linear39_out1 = self.linear39.forward(mul29_out1);
        let constant1773_out1 = self.constant1773.val();
        let mul30_out1 = linear39_out1
            .mul((constant1773_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add25_out1 = layernormalization20_out1.add(mul30_out1);
        add25_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule5 {
    layernormalization22: LayerNorm,
    linear40: Linear,
    linear41: Linear,
    linear42: Linear,
    constant168: burn::module::Param<Tensor<1>>,
    constant169: burn::module::Param<Tensor<4>>,
    linear43: Linear,
    constant1787: burn::module::Param<Tensor<1>>,
    linear44: Linear,
    layernormalization23: LayerNorm,
    conv1d13: Conv1d,
    conv1d14: Conv1d,
    conv1d15: Conv1d,
    layernormalization24: LayerNorm,
    linear45: Linear,
    linear46: Linear,
    constant1789: burn::module::Param<Tensor<1>>,
    layernormalization25: LayerNorm,
    layernormalization26: LayerNorm,
    linear47: Linear,
    linear48: Linear,
    constant1790: burn::module::Param<Tensor<1>>,
    layernormalization27: LayerNorm,
    linear49: Linear,
    linear50: Linear,
    linear51: Linear,
    constant203: burn::module::Param<Tensor<1>>,
    constant204: burn::module::Param<Tensor<4>>,
    linear52: Linear,
    constant1804: burn::module::Param<Tensor<1>>,
    linear53: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule5 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization22 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear40 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear41 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear42 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant168: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant169: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear43 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1787: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear44 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization23 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d13 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d14 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d15 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization24 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear45 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear46 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1789: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization25 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization26 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear47 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear48 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1790: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization27 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear49 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear50 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear51 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant203: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant204: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear52 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1804: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear53 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization22,
            linear40,
            linear41,
            linear42,
            constant168,
            constant169,
            linear43,
            constant1787,
            linear44,
            layernormalization23,
            conv1d13,
            conv1d14,
            conv1d15,
            layernormalization24,
            linear45,
            linear46,
            constant1789,
            layernormalization25,
            layernormalization26,
            linear47,
            linear48,
            constant1790,
            layernormalization27,
            linear49,
            linear50,
            linear51,
            constant203,
            constant204,
            linear52,
            constant1804,
            linear53,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add25_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization22_out1 = {
            let dtype = add25_out1.clone().dtype();
            self.layernormalization22
                .forward(add25_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear40_out1 = self.linear40.forward(layernormalization22_out1.clone());
        let linear41_out1 = self.linear41.forward(layernormalization22_out1.clone());
        let linear42_out1 = self.linear42.forward(layernormalization22_out1);
        let constant168_out1 = self.constant168.val();
        let add26_out1 = linear40_out1
            .clone()
            .add((constant168_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape19_out1 = linear40_out1.reshape([0, -1, 8, 160]);
        let transpose19_out1 = reshape19_out1.permute([0, 2, 1, 3]);
        let constant169_out1 = self.constant169.val();
        let add27_out1 = transpose19_out1.clone().add(constant169_out1);
        let linear43_out1 = self.linear43.forward(reshape2_out1.clone());
        let reshape20_out1 = linear43_out1.reshape([0, -1, 8, 160]);
        let transpose20_out1 = reshape20_out1.permute([0, 2, 3, 1]);
        let matmul49_out1 = add27_out1.matmul(transpose20_out1);
        let pad5_out1 = matmul49_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape6_out1: [i64; 4] = {
            let axes = &transpose19_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather6_out1 = shape6_out1[2] as i64;
        let unsqueeze9_out1 = [gather6_out1 as i64];
        let constant1779_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat10_out1: [i64; 4usize] = [&constant1779_out1[..], &unsqueeze9_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape21_out1 = pad5_out1.reshape(concat10_out1);
        let slice9_out1 = reshape21_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1783_out1: [i64; 2] = [0i64, 0i64];
        let constant1784_out1: [i64; 1] = [-1i64];
        let concat11_out1: [i64; 4usize] = [
            &constant1783_out1[..],
            &unsqueeze9_out1[..],
            &constant1784_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape22_out1 = slice9_out1.reshape(concat11_out1);
        let slice10_out1 = reshape22_out1.slice(s![.., .., .., 0..unsqueeze9_out1[0]]);
        let constant1787_out1 = self.constant1787.val();
        let mul31_out1 = slice10_out1
            .mul((constant1787_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention5_out1,) = {
            let q = add26_out1;
            let k = linear41_out1;
            let v = linear42_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul31_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention5_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention5_out1 = {
                let dims = attention5_out1.dims();
                attention5_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention5_out1 = attention5_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention5_out1,)
        };
        let linear44_out1 = self.linear44.forward(attention5_out1);
        let add28_out1 = add25_out1.add(linear44_out1);
        let layernormalization23_out1 = {
            let dtype = add28_out1.clone().dtype();
            self.layernormalization23
                .forward(add28_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose21_out1 = layernormalization23_out1.permute([0, 2, 1]);
        let conv1d13_out1 = self.conv1d13.forward(transpose21_out1);
        let split_tensors = conv1d13_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split5_out1, split5_out2] = split_tensors.try_into().unwrap();
        let sigmoid18_out1 = burn::tensor::activation::sigmoid(split5_out2);
        let mul32_out1 = split5_out1.mul(sigmoid18_out1);
        let conv1d14_out1 = self.conv1d14.forward(mul32_out1);
        let sigmoid19_out1 = burn::tensor::activation::sigmoid(conv1d14_out1.clone());
        let mul33_out1 = conv1d14_out1.mul(sigmoid19_out1);
        let conv1d15_out1 = self.conv1d15.forward(mul33_out1);
        let transpose22_out1 = conv1d15_out1.permute([0, 2, 1]);
        let add29_out1 = add28_out1.add(transpose22_out1);
        let layernormalization24_out1 = {
            let dtype = add29_out1.clone().dtype();
            self.layernormalization24
                .forward(add29_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear45_out1 = self.linear45.forward(layernormalization24_out1);
        let sigmoid20_out1 = burn::tensor::activation::sigmoid(linear45_out1.clone());
        let mul34_out1 = linear45_out1.mul(sigmoid20_out1);
        let linear46_out1 = self.linear46.forward(mul34_out1);
        let constant1789_out1 = self.constant1789.val();
        let mul35_out1 = linear46_out1
            .mul((constant1789_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add30_out1 = add29_out1.add(mul35_out1);
        let layernormalization25_out1 = {
            let dtype = add30_out1.dtype();
            self.layernormalization25
                .forward(add30_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization26_out1 = {
            let dtype = layernormalization25_out1.clone().dtype();
            self.layernormalization26
                .forward(
                    layernormalization25_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear47_out1 = self.linear47.forward(layernormalization26_out1);
        let sigmoid21_out1 = burn::tensor::activation::sigmoid(linear47_out1.clone());
        let mul36_out1 = linear47_out1.mul(sigmoid21_out1);
        let linear48_out1 = self.linear48.forward(mul36_out1);
        let constant1790_out1 = self.constant1790.val();
        let mul37_out1 = linear48_out1
            .mul((constant1790_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add31_out1 = layernormalization25_out1.add(mul37_out1);
        let layernormalization27_out1 = {
            let dtype = add31_out1.clone().dtype();
            self.layernormalization27
                .forward(add31_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear49_out1 = self.linear49.forward(layernormalization27_out1.clone());
        let linear50_out1 = self.linear50.forward(layernormalization27_out1.clone());
        let linear51_out1 = self.linear51.forward(layernormalization27_out1);
        let constant203_out1 = self.constant203.val();
        let add32_out1 = linear49_out1
            .clone()
            .add((constant203_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape23_out1 = linear49_out1.reshape([0, -1, 8, 160]);
        let transpose23_out1 = reshape23_out1.permute([0, 2, 1, 3]);
        let constant204_out1 = self.constant204.val();
        let add33_out1 = transpose23_out1.clone().add(constant204_out1);
        let linear52_out1 = self.linear52.forward(reshape2_out1);
        let reshape24_out1 = linear52_out1.reshape([0, -1, 8, 160]);
        let transpose24_out1 = reshape24_out1.permute([0, 2, 3, 1]);
        let matmul59_out1 = add33_out1.matmul(transpose24_out1);
        let pad6_out1 = matmul59_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape7_out1: [i64; 4] = {
            let axes = &transpose23_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather7_out1 = shape7_out1[2] as i64;
        let unsqueeze10_out1 = [gather7_out1 as i64];
        let constant1796_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat12_out1: [i64; 4usize] = [
            &constant1796_out1[..],
            &unsqueeze10_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape25_out1 = pad6_out1.reshape(concat12_out1);
        let slice11_out1 = reshape25_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1800_out1: [i64; 2] = [0i64, 0i64];
        let constant1801_out1: [i64; 1] = [-1i64];
        let concat13_out1: [i64; 4usize] = [
            &constant1800_out1[..],
            &unsqueeze10_out1[..],
            &constant1801_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape26_out1 = slice11_out1.reshape(concat13_out1);
        let slice12_out1 = reshape26_out1.slice(s![.., .., .., 0..unsqueeze10_out1[0]]);
        let constant1804_out1 = self.constant1804.val();
        let mul38_out1 = slice12_out1
            .mul((constant1804_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention6_out1,) = {
            let q = add32_out1;
            let k = linear50_out1;
            let v = linear51_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul38_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention6_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention6_out1 = {
                let dims = attention6_out1.dims();
                attention6_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention6_out1 = attention6_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention6_out1,)
        };
        let linear53_out1 = self.linear53.forward(attention6_out1);
        let add34_out1 = add31_out1.add(linear53_out1);
        add34_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule6 {
    layernormalization28: LayerNorm,
    conv1d16: Conv1d,
    conv1d17: Conv1d,
    conv1d18: Conv1d,
    layernormalization29: LayerNorm,
    linear54: Linear,
    linear55: Linear,
    constant1806: burn::module::Param<Tensor<1>>,
    layernormalization30: LayerNorm,
    layernormalization31: LayerNorm,
    linear56: Linear,
    linear57: Linear,
    constant1807: burn::module::Param<Tensor<1>>,
    layernormalization32: LayerNorm,
    linear58: Linear,
    linear59: Linear,
    linear60: Linear,
    constant238: burn::module::Param<Tensor<1>>,
    constant239: burn::module::Param<Tensor<4>>,
    linear61: Linear,
    constant1821: burn::module::Param<Tensor<1>>,
    linear62: Linear,
    layernormalization33: LayerNorm,
    conv1d19: Conv1d,
    conv1d20: Conv1d,
    conv1d21: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule6 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization28 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d16 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d17 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d18 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization29 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear54 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear55 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1806: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization30 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization31 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear56 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear57 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1807: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization32 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear58 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear59 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear60 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant238: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant239: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear61 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1821: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear62 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization33 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d19 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d20 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d21 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization28,
            conv1d16,
            conv1d17,
            conv1d18,
            layernormalization29,
            linear54,
            linear55,
            constant1806,
            layernormalization30,
            layernormalization31,
            linear56,
            linear57,
            constant1807,
            layernormalization32,
            linear58,
            linear59,
            linear60,
            constant238,
            constant239,
            linear61,
            constant1821,
            linear62,
            layernormalization33,
            conv1d19,
            conv1d20,
            conv1d21,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add34_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization28_out1 = {
            let dtype = add34_out1.clone().dtype();
            self.layernormalization28
                .forward(add34_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose25_out1 = layernormalization28_out1.permute([0, 2, 1]);
        let conv1d16_out1 = self.conv1d16.forward(transpose25_out1);
        let split_tensors = conv1d16_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split6_out1, split6_out2] = split_tensors.try_into().unwrap();
        let sigmoid22_out1 = burn::tensor::activation::sigmoid(split6_out2);
        let mul39_out1 = split6_out1.mul(sigmoid22_out1);
        let conv1d17_out1 = self.conv1d17.forward(mul39_out1);
        let sigmoid23_out1 = burn::tensor::activation::sigmoid(conv1d17_out1.clone());
        let mul40_out1 = conv1d17_out1.mul(sigmoid23_out1);
        let conv1d18_out1 = self.conv1d18.forward(mul40_out1);
        let transpose26_out1 = conv1d18_out1.permute([0, 2, 1]);
        let add35_out1 = add34_out1.add(transpose26_out1);
        let layernormalization29_out1 = {
            let dtype = add35_out1.clone().dtype();
            self.layernormalization29
                .forward(add35_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear54_out1 = self.linear54.forward(layernormalization29_out1);
        let sigmoid24_out1 = burn::tensor::activation::sigmoid(linear54_out1.clone());
        let mul41_out1 = linear54_out1.mul(sigmoid24_out1);
        let linear55_out1 = self.linear55.forward(mul41_out1);
        let constant1806_out1 = self.constant1806.val();
        let mul42_out1 = linear55_out1
            .mul((constant1806_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add36_out1 = add35_out1.add(mul42_out1);
        let layernormalization30_out1 = {
            let dtype = add36_out1.dtype();
            self.layernormalization30
                .forward(add36_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization31_out1 = {
            let dtype = layernormalization30_out1.clone().dtype();
            self.layernormalization31
                .forward(
                    layernormalization30_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear56_out1 = self.linear56.forward(layernormalization31_out1);
        let sigmoid25_out1 = burn::tensor::activation::sigmoid(linear56_out1.clone());
        let mul43_out1 = linear56_out1.mul(sigmoid25_out1);
        let linear57_out1 = self.linear57.forward(mul43_out1);
        let constant1807_out1 = self.constant1807.val();
        let mul44_out1 = linear57_out1
            .mul((constant1807_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add37_out1 = layernormalization30_out1.add(mul44_out1);
        let layernormalization32_out1 = {
            let dtype = add37_out1.clone().dtype();
            self.layernormalization32
                .forward(add37_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear58_out1 = self.linear58.forward(layernormalization32_out1.clone());
        let linear59_out1 = self.linear59.forward(layernormalization32_out1.clone());
        let linear60_out1 = self.linear60.forward(layernormalization32_out1);
        let constant238_out1 = self.constant238.val();
        let add38_out1 = linear58_out1
            .clone()
            .add((constant238_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape27_out1 = linear58_out1.reshape([0, -1, 8, 160]);
        let transpose27_out1 = reshape27_out1.permute([0, 2, 1, 3]);
        let constant239_out1 = self.constant239.val();
        let add39_out1 = transpose27_out1.clone().add(constant239_out1);
        let linear61_out1 = self.linear61.forward(reshape2_out1);
        let reshape28_out1 = linear61_out1.reshape([0, -1, 8, 160]);
        let transpose28_out1 = reshape28_out1.permute([0, 2, 3, 1]);
        let matmul69_out1 = add39_out1.matmul(transpose28_out1);
        let pad7_out1 = matmul69_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape8_out1: [i64; 4] = {
            let axes = &transpose27_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather8_out1 = shape8_out1[2] as i64;
        let unsqueeze11_out1 = [gather8_out1 as i64];
        let constant1813_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat14_out1: [i64; 4usize] = [
            &constant1813_out1[..],
            &unsqueeze11_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape29_out1 = pad7_out1.reshape(concat14_out1);
        let slice13_out1 = reshape29_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1817_out1: [i64; 2] = [0i64, 0i64];
        let constant1818_out1: [i64; 1] = [-1i64];
        let concat15_out1: [i64; 4usize] = [
            &constant1817_out1[..],
            &unsqueeze11_out1[..],
            &constant1818_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape30_out1 = slice13_out1.reshape(concat15_out1);
        let slice14_out1 = reshape30_out1.slice(s![.., .., .., 0..unsqueeze11_out1[0]]);
        let constant1821_out1 = self.constant1821.val();
        let mul45_out1 = slice14_out1
            .mul((constant1821_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention7_out1,) = {
            let q = add38_out1;
            let k = linear59_out1;
            let v = linear60_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul45_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention7_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention7_out1 = {
                let dims = attention7_out1.dims();
                attention7_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention7_out1 = attention7_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention7_out1,)
        };
        let linear62_out1 = self.linear62.forward(attention7_out1);
        let add40_out1 = add37_out1.add(linear62_out1);
        let layernormalization33_out1 = {
            let dtype = add40_out1.clone().dtype();
            self.layernormalization33
                .forward(add40_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose29_out1 = layernormalization33_out1.permute([0, 2, 1]);
        let conv1d19_out1 = self.conv1d19.forward(transpose29_out1);
        let split_tensors = conv1d19_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split7_out1, split7_out2] = split_tensors.try_into().unwrap();
        let sigmoid26_out1 = burn::tensor::activation::sigmoid(split7_out2);
        let mul46_out1 = split7_out1.mul(sigmoid26_out1);
        let conv1d20_out1 = self.conv1d20.forward(mul46_out1);
        let sigmoid27_out1 = burn::tensor::activation::sigmoid(conv1d20_out1.clone());
        let mul47_out1 = conv1d20_out1.mul(sigmoid27_out1);
        let conv1d21_out1 = self.conv1d21.forward(mul47_out1);
        let transpose30_out1 = conv1d21_out1.permute([0, 2, 1]);
        let add41_out1 = add40_out1.add(transpose30_out1);
        add41_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule7 {
    layernormalization34: LayerNorm,
    linear63: Linear,
    linear64: Linear,
    constant1823: burn::module::Param<Tensor<1>>,
    layernormalization35: LayerNorm,
    layernormalization36: LayerNorm,
    linear65: Linear,
    linear66: Linear,
    constant1824: burn::module::Param<Tensor<1>>,
    layernormalization37: LayerNorm,
    linear67: Linear,
    linear68: Linear,
    linear69: Linear,
    constant273: burn::module::Param<Tensor<1>>,
    constant274: burn::module::Param<Tensor<4>>,
    linear70: Linear,
    constant1838: burn::module::Param<Tensor<1>>,
    linear71: Linear,
    layernormalization38: LayerNorm,
    conv1d22: Conv1d,
    conv1d23: Conv1d,
    conv1d24: Conv1d,
    layernormalization39: LayerNorm,
    linear72: Linear,
    linear73: Linear,
    constant1840: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule7 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization34 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear63 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear64 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1823: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization35 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization36 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear65 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear66 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1824: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization37 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear67 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear68 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear69 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant273: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant274: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear70 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1838: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear71 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization38 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d22 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d23 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d24 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization39 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear72 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear73 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1840: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization34,
            linear63,
            linear64,
            constant1823,
            layernormalization35,
            layernormalization36,
            linear65,
            linear66,
            constant1824,
            layernormalization37,
            linear67,
            linear68,
            linear69,
            constant273,
            constant274,
            linear70,
            constant1838,
            linear71,
            layernormalization38,
            conv1d22,
            conv1d23,
            conv1d24,
            layernormalization39,
            linear72,
            linear73,
            constant1840,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add41_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization34_out1 = {
            let dtype = add41_out1.clone().dtype();
            self.layernormalization34
                .forward(add41_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear63_out1 = self.linear63.forward(layernormalization34_out1);
        let sigmoid28_out1 = burn::tensor::activation::sigmoid(linear63_out1.clone());
        let mul48_out1 = linear63_out1.mul(sigmoid28_out1);
        let linear64_out1 = self.linear64.forward(mul48_out1);
        let constant1823_out1 = self.constant1823.val();
        let mul49_out1 = linear64_out1
            .mul((constant1823_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add42_out1 = add41_out1.add(mul49_out1);
        let layernormalization35_out1 = {
            let dtype = add42_out1.dtype();
            self.layernormalization35
                .forward(add42_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization36_out1 = {
            let dtype = layernormalization35_out1.clone().dtype();
            self.layernormalization36
                .forward(
                    layernormalization35_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear65_out1 = self.linear65.forward(layernormalization36_out1);
        let sigmoid29_out1 = burn::tensor::activation::sigmoid(linear65_out1.clone());
        let mul50_out1 = linear65_out1.mul(sigmoid29_out1);
        let linear66_out1 = self.linear66.forward(mul50_out1);
        let constant1824_out1 = self.constant1824.val();
        let mul51_out1 = linear66_out1
            .mul((constant1824_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add43_out1 = layernormalization35_out1.add(mul51_out1);
        let layernormalization37_out1 = {
            let dtype = add43_out1.clone().dtype();
            self.layernormalization37
                .forward(add43_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear67_out1 = self.linear67.forward(layernormalization37_out1.clone());
        let linear68_out1 = self.linear68.forward(layernormalization37_out1.clone());
        let linear69_out1 = self.linear69.forward(layernormalization37_out1);
        let constant273_out1 = self.constant273.val();
        let add44_out1 = linear67_out1
            .clone()
            .add((constant273_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape31_out1 = linear67_out1.reshape([0, -1, 8, 160]);
        let transpose31_out1 = reshape31_out1.permute([0, 2, 1, 3]);
        let constant274_out1 = self.constant274.val();
        let add45_out1 = transpose31_out1.clone().add(constant274_out1);
        let linear70_out1 = self.linear70.forward(reshape2_out1);
        let reshape32_out1 = linear70_out1.reshape([0, -1, 8, 160]);
        let transpose32_out1 = reshape32_out1.permute([0, 2, 3, 1]);
        let matmul79_out1 = add45_out1.matmul(transpose32_out1);
        let pad8_out1 = matmul79_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape9_out1: [i64; 4] = {
            let axes = &transpose31_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather9_out1 = shape9_out1[2] as i64;
        let unsqueeze12_out1 = [gather9_out1 as i64];
        let constant1830_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat16_out1: [i64; 4usize] = [
            &constant1830_out1[..],
            &unsqueeze12_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape33_out1 = pad8_out1.reshape(concat16_out1);
        let slice15_out1 = reshape33_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1834_out1: [i64; 2] = [0i64, 0i64];
        let constant1835_out1: [i64; 1] = [-1i64];
        let concat17_out1: [i64; 4usize] = [
            &constant1834_out1[..],
            &unsqueeze12_out1[..],
            &constant1835_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape34_out1 = slice15_out1.reshape(concat17_out1);
        let slice16_out1 = reshape34_out1.slice(s![.., .., .., 0..unsqueeze12_out1[0]]);
        let constant1838_out1 = self.constant1838.val();
        let mul52_out1 = slice16_out1
            .mul((constant1838_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention8_out1,) = {
            let q = add44_out1;
            let k = linear68_out1;
            let v = linear69_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul52_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention8_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention8_out1 = {
                let dims = attention8_out1.dims();
                attention8_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention8_out1 = attention8_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention8_out1,)
        };
        let linear71_out1 = self.linear71.forward(attention8_out1);
        let add46_out1 = add43_out1.add(linear71_out1);
        let layernormalization38_out1 = {
            let dtype = add46_out1.clone().dtype();
            self.layernormalization38
                .forward(add46_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose33_out1 = layernormalization38_out1.permute([0, 2, 1]);
        let conv1d22_out1 = self.conv1d22.forward(transpose33_out1);
        let split_tensors = conv1d22_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split8_out1, split8_out2] = split_tensors.try_into().unwrap();
        let sigmoid30_out1 = burn::tensor::activation::sigmoid(split8_out2);
        let mul53_out1 = split8_out1.mul(sigmoid30_out1);
        let conv1d23_out1 = self.conv1d23.forward(mul53_out1);
        let sigmoid31_out1 = burn::tensor::activation::sigmoid(conv1d23_out1.clone());
        let mul54_out1 = conv1d23_out1.mul(sigmoid31_out1);
        let conv1d24_out1 = self.conv1d24.forward(mul54_out1);
        let transpose34_out1 = conv1d24_out1.permute([0, 2, 1]);
        let add47_out1 = add46_out1.add(transpose34_out1);
        let layernormalization39_out1 = {
            let dtype = add47_out1.clone().dtype();
            self.layernormalization39
                .forward(add47_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear72_out1 = self.linear72.forward(layernormalization39_out1);
        let sigmoid32_out1 = burn::tensor::activation::sigmoid(linear72_out1.clone());
        let mul55_out1 = linear72_out1.mul(sigmoid32_out1);
        let linear73_out1 = self.linear73.forward(mul55_out1);
        let constant1840_out1 = self.constant1840.val();
        let mul56_out1 = linear73_out1
            .mul((constant1840_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add48_out1 = add47_out1.add(mul56_out1);
        add48_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule8 {
    layernormalization40: LayerNorm,
    layernormalization41: LayerNorm,
    linear74: Linear,
    linear75: Linear,
    constant1841: burn::module::Param<Tensor<1>>,
    layernormalization42: LayerNorm,
    linear76: Linear,
    linear77: Linear,
    linear78: Linear,
    constant308: burn::module::Param<Tensor<1>>,
    constant309: burn::module::Param<Tensor<4>>,
    linear79: Linear,
    constant1855: burn::module::Param<Tensor<1>>,
    linear80: Linear,
    layernormalization43: LayerNorm,
    conv1d25: Conv1d,
    conv1d26: Conv1d,
    conv1d27: Conv1d,
    layernormalization44: LayerNorm,
    linear81: Linear,
    linear82: Linear,
    constant1857: burn::module::Param<Tensor<1>>,
    layernormalization45: LayerNorm,
    layernormalization46: LayerNorm,
    linear83: Linear,
    linear84: Linear,
    constant1858: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule8 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization40 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization41 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear74 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear75 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1841: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization42 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear76 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear77 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear78 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant308: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant309: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear79 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1855: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear80 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization43 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d25 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d26 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d27 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization44 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear81 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear82 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1857: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization45 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization46 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear83 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear84 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1858: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization40,
            layernormalization41,
            linear74,
            linear75,
            constant1841,
            layernormalization42,
            linear76,
            linear77,
            linear78,
            constant308,
            constant309,
            linear79,
            constant1855,
            linear80,
            layernormalization43,
            conv1d25,
            conv1d26,
            conv1d27,
            layernormalization44,
            linear81,
            linear82,
            constant1857,
            layernormalization45,
            layernormalization46,
            linear83,
            linear84,
            constant1858,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add48_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization40_out1 = {
            let dtype = add48_out1.dtype();
            self.layernormalization40
                .forward(add48_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization41_out1 = {
            let dtype = layernormalization40_out1.clone().dtype();
            self.layernormalization41
                .forward(
                    layernormalization40_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear74_out1 = self.linear74.forward(layernormalization41_out1);
        let sigmoid33_out1 = burn::tensor::activation::sigmoid(linear74_out1.clone());
        let mul57_out1 = linear74_out1.mul(sigmoid33_out1);
        let linear75_out1 = self.linear75.forward(mul57_out1);
        let constant1841_out1 = self.constant1841.val();
        let mul58_out1 = linear75_out1
            .mul((constant1841_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add49_out1 = layernormalization40_out1.add(mul58_out1);
        let layernormalization42_out1 = {
            let dtype = add49_out1.clone().dtype();
            self.layernormalization42
                .forward(add49_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear76_out1 = self.linear76.forward(layernormalization42_out1.clone());
        let linear77_out1 = self.linear77.forward(layernormalization42_out1.clone());
        let linear78_out1 = self.linear78.forward(layernormalization42_out1);
        let constant308_out1 = self.constant308.val();
        let add50_out1 = linear76_out1
            .clone()
            .add((constant308_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape35_out1 = linear76_out1.reshape([0, -1, 8, 160]);
        let transpose35_out1 = reshape35_out1.permute([0, 2, 1, 3]);
        let constant309_out1 = self.constant309.val();
        let add51_out1 = transpose35_out1.clone().add(constant309_out1);
        let linear79_out1 = self.linear79.forward(reshape2_out1);
        let reshape36_out1 = linear79_out1.reshape([0, -1, 8, 160]);
        let transpose36_out1 = reshape36_out1.permute([0, 2, 3, 1]);
        let matmul89_out1 = add51_out1.matmul(transpose36_out1);
        let pad9_out1 = matmul89_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape10_out1: [i64; 4] = {
            let axes = &transpose35_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather10_out1 = shape10_out1[2] as i64;
        let unsqueeze13_out1 = [gather10_out1 as i64];
        let constant1847_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat18_out1: [i64; 4usize] = [
            &constant1847_out1[..],
            &unsqueeze13_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape37_out1 = pad9_out1.reshape(concat18_out1);
        let slice17_out1 = reshape37_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1851_out1: [i64; 2] = [0i64, 0i64];
        let constant1852_out1: [i64; 1] = [-1i64];
        let concat19_out1: [i64; 4usize] = [
            &constant1851_out1[..],
            &unsqueeze13_out1[..],
            &constant1852_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape38_out1 = slice17_out1.reshape(concat19_out1);
        let slice18_out1 = reshape38_out1.slice(s![.., .., .., 0..unsqueeze13_out1[0]]);
        let constant1855_out1 = self.constant1855.val();
        let mul59_out1 = slice18_out1
            .mul((constant1855_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention9_out1,) = {
            let q = add50_out1;
            let k = linear77_out1;
            let v = linear78_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul59_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention9_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention9_out1 = {
                let dims = attention9_out1.dims();
                attention9_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention9_out1 = attention9_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention9_out1,)
        };
        let linear80_out1 = self.linear80.forward(attention9_out1);
        let add52_out1 = add49_out1.add(linear80_out1);
        let layernormalization43_out1 = {
            let dtype = add52_out1.clone().dtype();
            self.layernormalization43
                .forward(add52_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose37_out1 = layernormalization43_out1.permute([0, 2, 1]);
        let conv1d25_out1 = self.conv1d25.forward(transpose37_out1);
        let split_tensors = conv1d25_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split9_out1, split9_out2] = split_tensors.try_into().unwrap();
        let sigmoid34_out1 = burn::tensor::activation::sigmoid(split9_out2);
        let mul60_out1 = split9_out1.mul(sigmoid34_out1);
        let conv1d26_out1 = self.conv1d26.forward(mul60_out1);
        let sigmoid35_out1 = burn::tensor::activation::sigmoid(conv1d26_out1.clone());
        let mul61_out1 = conv1d26_out1.mul(sigmoid35_out1);
        let conv1d27_out1 = self.conv1d27.forward(mul61_out1);
        let transpose38_out1 = conv1d27_out1.permute([0, 2, 1]);
        let add53_out1 = add52_out1.add(transpose38_out1);
        let layernormalization44_out1 = {
            let dtype = add53_out1.clone().dtype();
            self.layernormalization44
                .forward(add53_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear81_out1 = self.linear81.forward(layernormalization44_out1);
        let sigmoid36_out1 = burn::tensor::activation::sigmoid(linear81_out1.clone());
        let mul62_out1 = linear81_out1.mul(sigmoid36_out1);
        let linear82_out1 = self.linear82.forward(mul62_out1);
        let constant1857_out1 = self.constant1857.val();
        let mul63_out1 = linear82_out1
            .mul((constant1857_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add54_out1 = add53_out1.add(mul63_out1);
        let layernormalization45_out1 = {
            let dtype = add54_out1.dtype();
            self.layernormalization45
                .forward(add54_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization46_out1 = {
            let dtype = layernormalization45_out1.clone().dtype();
            self.layernormalization46
                .forward(
                    layernormalization45_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear83_out1 = self.linear83.forward(layernormalization46_out1);
        let sigmoid37_out1 = burn::tensor::activation::sigmoid(linear83_out1.clone());
        let mul64_out1 = linear83_out1.mul(sigmoid37_out1);
        let linear84_out1 = self.linear84.forward(mul64_out1);
        let constant1858_out1 = self.constant1858.val();
        let mul65_out1 = linear84_out1
            .mul((constant1858_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add55_out1 = layernormalization45_out1.add(mul65_out1);
        add55_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule9 {
    layernormalization47: LayerNorm,
    linear85: Linear,
    linear86: Linear,
    linear87: Linear,
    constant343: burn::module::Param<Tensor<1>>,
    constant344: burn::module::Param<Tensor<4>>,
    linear88: Linear,
    constant1872: burn::module::Param<Tensor<1>>,
    linear89: Linear,
    layernormalization48: LayerNorm,
    conv1d28: Conv1d,
    conv1d29: Conv1d,
    conv1d30: Conv1d,
    layernormalization49: LayerNorm,
    linear90: Linear,
    linear91: Linear,
    constant1874: burn::module::Param<Tensor<1>>,
    layernormalization50: LayerNorm,
    layernormalization51: LayerNorm,
    linear92: Linear,
    linear93: Linear,
    constant1875: burn::module::Param<Tensor<1>>,
    layernormalization52: LayerNorm,
    linear94: Linear,
    linear95: Linear,
    linear96: Linear,
    constant378: burn::module::Param<Tensor<1>>,
    constant379: burn::module::Param<Tensor<4>>,
    linear97: Linear,
    constant1889: burn::module::Param<Tensor<1>>,
    linear98: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule9 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization47 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear85 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear86 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear87 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant343: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant344: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear88 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1872: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear89 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization48 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d28 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d29 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d30 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization49 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear90 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear91 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1874: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization50 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization51 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear92 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear93 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1875: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization52 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear94 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear95 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear96 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant378: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant379: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear97 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1889: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear98 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization47,
            linear85,
            linear86,
            linear87,
            constant343,
            constant344,
            linear88,
            constant1872,
            linear89,
            layernormalization48,
            conv1d28,
            conv1d29,
            conv1d30,
            layernormalization49,
            linear90,
            linear91,
            constant1874,
            layernormalization50,
            layernormalization51,
            linear92,
            linear93,
            constant1875,
            layernormalization52,
            linear94,
            linear95,
            linear96,
            constant378,
            constant379,
            linear97,
            constant1889,
            linear98,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add55_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization47_out1 = {
            let dtype = add55_out1.clone().dtype();
            self.layernormalization47
                .forward(add55_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear85_out1 = self.linear85.forward(layernormalization47_out1.clone());
        let linear86_out1 = self.linear86.forward(layernormalization47_out1.clone());
        let linear87_out1 = self.linear87.forward(layernormalization47_out1);
        let constant343_out1 = self.constant343.val();
        let add56_out1 = linear85_out1
            .clone()
            .add((constant343_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape39_out1 = linear85_out1.reshape([0, -1, 8, 160]);
        let transpose39_out1 = reshape39_out1.permute([0, 2, 1, 3]);
        let constant344_out1 = self.constant344.val();
        let add57_out1 = transpose39_out1.clone().add(constant344_out1);
        let linear88_out1 = self.linear88.forward(reshape2_out1.clone());
        let reshape40_out1 = linear88_out1.reshape([0, -1, 8, 160]);
        let transpose40_out1 = reshape40_out1.permute([0, 2, 3, 1]);
        let matmul99_out1 = add57_out1.matmul(transpose40_out1);
        let pad10_out1 = matmul99_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape11_out1: [i64; 4] = {
            let axes = &transpose39_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather11_out1 = shape11_out1[2] as i64;
        let unsqueeze14_out1 = [gather11_out1 as i64];
        let constant1864_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat20_out1: [i64; 4usize] = [
            &constant1864_out1[..],
            &unsqueeze14_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape41_out1 = pad10_out1.reshape(concat20_out1);
        let slice19_out1 = reshape41_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1868_out1: [i64; 2] = [0i64, 0i64];
        let constant1869_out1: [i64; 1] = [-1i64];
        let concat21_out1: [i64; 4usize] = [
            &constant1868_out1[..],
            &unsqueeze14_out1[..],
            &constant1869_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape42_out1 = slice19_out1.reshape(concat21_out1);
        let slice20_out1 = reshape42_out1.slice(s![.., .., .., 0..unsqueeze14_out1[0]]);
        let constant1872_out1 = self.constant1872.val();
        let mul66_out1 = slice20_out1
            .mul((constant1872_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention10_out1,) = {
            let q = add56_out1;
            let k = linear86_out1;
            let v = linear87_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul66_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention10_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention10_out1 = {
                let dims = attention10_out1.dims();
                attention10_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention10_out1 = attention10_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention10_out1,)
        };
        let linear89_out1 = self.linear89.forward(attention10_out1);
        let add58_out1 = add55_out1.add(linear89_out1);
        let layernormalization48_out1 = {
            let dtype = add58_out1.clone().dtype();
            self.layernormalization48
                .forward(add58_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose41_out1 = layernormalization48_out1.permute([0, 2, 1]);
        let conv1d28_out1 = self.conv1d28.forward(transpose41_out1);
        let split_tensors = conv1d28_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split10_out1, split10_out2] = split_tensors.try_into().unwrap();
        let sigmoid38_out1 = burn::tensor::activation::sigmoid(split10_out2);
        let mul67_out1 = split10_out1.mul(sigmoid38_out1);
        let conv1d29_out1 = self.conv1d29.forward(mul67_out1);
        let sigmoid39_out1 = burn::tensor::activation::sigmoid(conv1d29_out1.clone());
        let mul68_out1 = conv1d29_out1.mul(sigmoid39_out1);
        let conv1d30_out1 = self.conv1d30.forward(mul68_out1);
        let transpose42_out1 = conv1d30_out1.permute([0, 2, 1]);
        let add59_out1 = add58_out1.add(transpose42_out1);
        let layernormalization49_out1 = {
            let dtype = add59_out1.clone().dtype();
            self.layernormalization49
                .forward(add59_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear90_out1 = self.linear90.forward(layernormalization49_out1);
        let sigmoid40_out1 = burn::tensor::activation::sigmoid(linear90_out1.clone());
        let mul69_out1 = linear90_out1.mul(sigmoid40_out1);
        let linear91_out1 = self.linear91.forward(mul69_out1);
        let constant1874_out1 = self.constant1874.val();
        let mul70_out1 = linear91_out1
            .mul((constant1874_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add60_out1 = add59_out1.add(mul70_out1);
        let layernormalization50_out1 = {
            let dtype = add60_out1.dtype();
            self.layernormalization50
                .forward(add60_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization51_out1 = {
            let dtype = layernormalization50_out1.clone().dtype();
            self.layernormalization51
                .forward(
                    layernormalization50_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear92_out1 = self.linear92.forward(layernormalization51_out1);
        let sigmoid41_out1 = burn::tensor::activation::sigmoid(linear92_out1.clone());
        let mul71_out1 = linear92_out1.mul(sigmoid41_out1);
        let linear93_out1 = self.linear93.forward(mul71_out1);
        let constant1875_out1 = self.constant1875.val();
        let mul72_out1 = linear93_out1
            .mul((constant1875_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add61_out1 = layernormalization50_out1.add(mul72_out1);
        let layernormalization52_out1 = {
            let dtype = add61_out1.clone().dtype();
            self.layernormalization52
                .forward(add61_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear94_out1 = self.linear94.forward(layernormalization52_out1.clone());
        let linear95_out1 = self.linear95.forward(layernormalization52_out1.clone());
        let linear96_out1 = self.linear96.forward(layernormalization52_out1);
        let constant378_out1 = self.constant378.val();
        let add62_out1 = linear94_out1
            .clone()
            .add((constant378_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape43_out1 = linear94_out1.reshape([0, -1, 8, 160]);
        let transpose43_out1 = reshape43_out1.permute([0, 2, 1, 3]);
        let constant379_out1 = self.constant379.val();
        let add63_out1 = transpose43_out1.clone().add(constant379_out1);
        let linear97_out1 = self.linear97.forward(reshape2_out1);
        let reshape44_out1 = linear97_out1.reshape([0, -1, 8, 160]);
        let transpose44_out1 = reshape44_out1.permute([0, 2, 3, 1]);
        let matmul109_out1 = add63_out1.matmul(transpose44_out1);
        let pad11_out1 = matmul109_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape12_out1: [i64; 4] = {
            let axes = &transpose43_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather12_out1 = shape12_out1[2] as i64;
        let unsqueeze15_out1 = [gather12_out1 as i64];
        let constant1881_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat22_out1: [i64; 4usize] = [
            &constant1881_out1[..],
            &unsqueeze15_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape45_out1 = pad11_out1.reshape(concat22_out1);
        let slice21_out1 = reshape45_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1885_out1: [i64; 2] = [0i64, 0i64];
        let constant1886_out1: [i64; 1] = [-1i64];
        let concat23_out1: [i64; 4usize] = [
            &constant1885_out1[..],
            &unsqueeze15_out1[..],
            &constant1886_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape46_out1 = slice21_out1.reshape(concat23_out1);
        let slice22_out1 = reshape46_out1.slice(s![.., .., .., 0..unsqueeze15_out1[0]]);
        let constant1889_out1 = self.constant1889.val();
        let mul73_out1 = slice22_out1
            .mul((constant1889_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention11_out1,) = {
            let q = add62_out1;
            let k = linear95_out1;
            let v = linear96_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul73_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention11_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention11_out1 = {
                let dims = attention11_out1.dims();
                attention11_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention11_out1 = attention11_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention11_out1,)
        };
        let linear98_out1 = self.linear98.forward(attention11_out1);
        let add64_out1 = add61_out1.add(linear98_out1);
        add64_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule10 {
    layernormalization53: LayerNorm,
    conv1d31: Conv1d,
    conv1d32: Conv1d,
    conv1d33: Conv1d,
    layernormalization54: LayerNorm,
    linear99: Linear,
    linear100: Linear,
    constant1891: burn::module::Param<Tensor<1>>,
    layernormalization55: LayerNorm,
    layernormalization56: LayerNorm,
    linear101: Linear,
    linear102: Linear,
    constant1892: burn::module::Param<Tensor<1>>,
    layernormalization57: LayerNorm,
    linear103: Linear,
    linear104: Linear,
    linear105: Linear,
    constant413: burn::module::Param<Tensor<1>>,
    constant414: burn::module::Param<Tensor<4>>,
    linear106: Linear,
    constant1906: burn::module::Param<Tensor<1>>,
    linear107: Linear,
    layernormalization58: LayerNorm,
    conv1d34: Conv1d,
    conv1d35: Conv1d,
    conv1d36: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule10 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization53 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d31 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d32 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d33 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization54 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear99 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear100 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1891: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization55 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization56 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear101 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear102 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1892: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization57 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear103 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear104 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear105 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant413: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant414: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear106 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1906: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear107 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization58 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d34 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d35 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d36 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization53,
            conv1d31,
            conv1d32,
            conv1d33,
            layernormalization54,
            linear99,
            linear100,
            constant1891,
            layernormalization55,
            layernormalization56,
            linear101,
            linear102,
            constant1892,
            layernormalization57,
            linear103,
            linear104,
            linear105,
            constant413,
            constant414,
            linear106,
            constant1906,
            linear107,
            layernormalization58,
            conv1d34,
            conv1d35,
            conv1d36,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add64_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization53_out1 = {
            let dtype = add64_out1.clone().dtype();
            self.layernormalization53
                .forward(add64_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose45_out1 = layernormalization53_out1.permute([0, 2, 1]);
        let conv1d31_out1 = self.conv1d31.forward(transpose45_out1);
        let split_tensors = conv1d31_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split11_out1, split11_out2] = split_tensors.try_into().unwrap();
        let sigmoid42_out1 = burn::tensor::activation::sigmoid(split11_out2);
        let mul74_out1 = split11_out1.mul(sigmoid42_out1);
        let conv1d32_out1 = self.conv1d32.forward(mul74_out1);
        let sigmoid43_out1 = burn::tensor::activation::sigmoid(conv1d32_out1.clone());
        let mul75_out1 = conv1d32_out1.mul(sigmoid43_out1);
        let conv1d33_out1 = self.conv1d33.forward(mul75_out1);
        let transpose46_out1 = conv1d33_out1.permute([0, 2, 1]);
        let add65_out1 = add64_out1.add(transpose46_out1);
        let layernormalization54_out1 = {
            let dtype = add65_out1.clone().dtype();
            self.layernormalization54
                .forward(add65_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear99_out1 = self.linear99.forward(layernormalization54_out1);
        let sigmoid44_out1 = burn::tensor::activation::sigmoid(linear99_out1.clone());
        let mul76_out1 = linear99_out1.mul(sigmoid44_out1);
        let linear100_out1 = self.linear100.forward(mul76_out1);
        let constant1891_out1 = self.constant1891.val();
        let mul77_out1 = linear100_out1
            .mul((constant1891_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add66_out1 = add65_out1.add(mul77_out1);
        let layernormalization55_out1 = {
            let dtype = add66_out1.dtype();
            self.layernormalization55
                .forward(add66_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization56_out1 = {
            let dtype = layernormalization55_out1.clone().dtype();
            self.layernormalization56
                .forward(
                    layernormalization55_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear101_out1 = self.linear101.forward(layernormalization56_out1);
        let sigmoid45_out1 = burn::tensor::activation::sigmoid(linear101_out1.clone());
        let mul78_out1 = linear101_out1.mul(sigmoid45_out1);
        let linear102_out1 = self.linear102.forward(mul78_out1);
        let constant1892_out1 = self.constant1892.val();
        let mul79_out1 = linear102_out1
            .mul((constant1892_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add67_out1 = layernormalization55_out1.add(mul79_out1);
        let layernormalization57_out1 = {
            let dtype = add67_out1.clone().dtype();
            self.layernormalization57
                .forward(add67_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear103_out1 = self.linear103.forward(layernormalization57_out1.clone());
        let linear104_out1 = self.linear104.forward(layernormalization57_out1.clone());
        let linear105_out1 = self.linear105.forward(layernormalization57_out1);
        let constant413_out1 = self.constant413.val();
        let add68_out1 = linear103_out1
            .clone()
            .add((constant413_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape47_out1 = linear103_out1.reshape([0, -1, 8, 160]);
        let transpose47_out1 = reshape47_out1.permute([0, 2, 1, 3]);
        let constant414_out1 = self.constant414.val();
        let add69_out1 = transpose47_out1.clone().add(constant414_out1);
        let linear106_out1 = self.linear106.forward(reshape2_out1);
        let reshape48_out1 = linear106_out1.reshape([0, -1, 8, 160]);
        let transpose48_out1 = reshape48_out1.permute([0, 2, 3, 1]);
        let matmul119_out1 = add69_out1.matmul(transpose48_out1);
        let pad12_out1 = matmul119_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape13_out1: [i64; 4] = {
            let axes = &transpose47_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather13_out1 = shape13_out1[2] as i64;
        let unsqueeze16_out1 = [gather13_out1 as i64];
        let constant1898_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat24_out1: [i64; 4usize] = [
            &constant1898_out1[..],
            &unsqueeze16_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape49_out1 = pad12_out1.reshape(concat24_out1);
        let slice23_out1 = reshape49_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1902_out1: [i64; 2] = [0i64, 0i64];
        let constant1903_out1: [i64; 1] = [-1i64];
        let concat25_out1: [i64; 4usize] = [
            &constant1902_out1[..],
            &unsqueeze16_out1[..],
            &constant1903_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape50_out1 = slice23_out1.reshape(concat25_out1);
        let slice24_out1 = reshape50_out1.slice(s![.., .., .., 0..unsqueeze16_out1[0]]);
        let constant1906_out1 = self.constant1906.val();
        let mul80_out1 = slice24_out1
            .mul((constant1906_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention12_out1,) = {
            let q = add68_out1;
            let k = linear104_out1;
            let v = linear105_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul80_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention12_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention12_out1 = {
                let dims = attention12_out1.dims();
                attention12_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention12_out1 = attention12_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention12_out1,)
        };
        let linear107_out1 = self.linear107.forward(attention12_out1);
        let add70_out1 = add67_out1.add(linear107_out1);
        let layernormalization58_out1 = {
            let dtype = add70_out1.clone().dtype();
            self.layernormalization58
                .forward(add70_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose49_out1 = layernormalization58_out1.permute([0, 2, 1]);
        let conv1d34_out1 = self.conv1d34.forward(transpose49_out1);
        let split_tensors = conv1d34_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split12_out1, split12_out2] = split_tensors.try_into().unwrap();
        let sigmoid46_out1 = burn::tensor::activation::sigmoid(split12_out2);
        let mul81_out1 = split12_out1.mul(sigmoid46_out1);
        let conv1d35_out1 = self.conv1d35.forward(mul81_out1);
        let sigmoid47_out1 = burn::tensor::activation::sigmoid(conv1d35_out1.clone());
        let mul82_out1 = conv1d35_out1.mul(sigmoid47_out1);
        let conv1d36_out1 = self.conv1d36.forward(mul82_out1);
        let transpose50_out1 = conv1d36_out1.permute([0, 2, 1]);
        let add71_out1 = add70_out1.add(transpose50_out1);
        add71_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule11 {
    layernormalization59: LayerNorm,
    linear108: Linear,
    linear109: Linear,
    constant1908: burn::module::Param<Tensor<1>>,
    layernormalization60: LayerNorm,
    layernormalization61: LayerNorm,
    linear110: Linear,
    linear111: Linear,
    constant1909: burn::module::Param<Tensor<1>>,
    layernormalization62: LayerNorm,
    linear112: Linear,
    linear113: Linear,
    linear114: Linear,
    constant448: burn::module::Param<Tensor<1>>,
    constant449: burn::module::Param<Tensor<4>>,
    linear115: Linear,
    constant1923: burn::module::Param<Tensor<1>>,
    linear116: Linear,
    layernormalization63: LayerNorm,
    conv1d37: Conv1d,
    conv1d38: Conv1d,
    conv1d39: Conv1d,
    layernormalization64: LayerNorm,
    linear117: Linear,
    linear118: Linear,
    constant1925: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule11 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization59 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear108 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear109 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1908: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization60 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization61 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear110 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear111 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1909: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization62 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear112 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear113 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear114 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant448: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant449: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear115 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1923: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear116 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization63 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d37 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d38 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d39 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization64 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear117 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear118 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1925: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization59,
            linear108,
            linear109,
            constant1908,
            layernormalization60,
            layernormalization61,
            linear110,
            linear111,
            constant1909,
            layernormalization62,
            linear112,
            linear113,
            linear114,
            constant448,
            constant449,
            linear115,
            constant1923,
            linear116,
            layernormalization63,
            conv1d37,
            conv1d38,
            conv1d39,
            layernormalization64,
            linear117,
            linear118,
            constant1925,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add71_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization59_out1 = {
            let dtype = add71_out1.clone().dtype();
            self.layernormalization59
                .forward(add71_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear108_out1 = self.linear108.forward(layernormalization59_out1);
        let sigmoid48_out1 = burn::tensor::activation::sigmoid(linear108_out1.clone());
        let mul83_out1 = linear108_out1.mul(sigmoid48_out1);
        let linear109_out1 = self.linear109.forward(mul83_out1);
        let constant1908_out1 = self.constant1908.val();
        let mul84_out1 = linear109_out1
            .mul((constant1908_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add72_out1 = add71_out1.add(mul84_out1);
        let layernormalization60_out1 = {
            let dtype = add72_out1.dtype();
            self.layernormalization60
                .forward(add72_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization61_out1 = {
            let dtype = layernormalization60_out1.clone().dtype();
            self.layernormalization61
                .forward(
                    layernormalization60_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear110_out1 = self.linear110.forward(layernormalization61_out1);
        let sigmoid49_out1 = burn::tensor::activation::sigmoid(linear110_out1.clone());
        let mul85_out1 = linear110_out1.mul(sigmoid49_out1);
        let linear111_out1 = self.linear111.forward(mul85_out1);
        let constant1909_out1 = self.constant1909.val();
        let mul86_out1 = linear111_out1
            .mul((constant1909_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add73_out1 = layernormalization60_out1.add(mul86_out1);
        let layernormalization62_out1 = {
            let dtype = add73_out1.clone().dtype();
            self.layernormalization62
                .forward(add73_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear112_out1 = self.linear112.forward(layernormalization62_out1.clone());
        let linear113_out1 = self.linear113.forward(layernormalization62_out1.clone());
        let linear114_out1 = self.linear114.forward(layernormalization62_out1);
        let constant448_out1 = self.constant448.val();
        let add74_out1 = linear112_out1
            .clone()
            .add((constant448_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape51_out1 = linear112_out1.reshape([0, -1, 8, 160]);
        let transpose51_out1 = reshape51_out1.permute([0, 2, 1, 3]);
        let constant449_out1 = self.constant449.val();
        let add75_out1 = transpose51_out1.clone().add(constant449_out1);
        let linear115_out1 = self.linear115.forward(reshape2_out1);
        let reshape52_out1 = linear115_out1.reshape([0, -1, 8, 160]);
        let transpose52_out1 = reshape52_out1.permute([0, 2, 3, 1]);
        let matmul129_out1 = add75_out1.matmul(transpose52_out1);
        let pad13_out1 = matmul129_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape14_out1: [i64; 4] = {
            let axes = &transpose51_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather14_out1 = shape14_out1[2] as i64;
        let unsqueeze17_out1 = [gather14_out1 as i64];
        let constant1915_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat26_out1: [i64; 4usize] = [
            &constant1915_out1[..],
            &unsqueeze17_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape53_out1 = pad13_out1.reshape(concat26_out1);
        let slice25_out1 = reshape53_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1919_out1: [i64; 2] = [0i64, 0i64];
        let constant1920_out1: [i64; 1] = [-1i64];
        let concat27_out1: [i64; 4usize] = [
            &constant1919_out1[..],
            &unsqueeze17_out1[..],
            &constant1920_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape54_out1 = slice25_out1.reshape(concat27_out1);
        let slice26_out1 = reshape54_out1.slice(s![.., .., .., 0..unsqueeze17_out1[0]]);
        let constant1923_out1 = self.constant1923.val();
        let mul87_out1 = slice26_out1
            .mul((constant1923_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention13_out1,) = {
            let q = add74_out1;
            let k = linear113_out1;
            let v = linear114_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul87_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention13_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention13_out1 = {
                let dims = attention13_out1.dims();
                attention13_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention13_out1 = attention13_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention13_out1,)
        };
        let linear116_out1 = self.linear116.forward(attention13_out1);
        let add76_out1 = add73_out1.add(linear116_out1);
        let layernormalization63_out1 = {
            let dtype = add76_out1.clone().dtype();
            self.layernormalization63
                .forward(add76_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose53_out1 = layernormalization63_out1.permute([0, 2, 1]);
        let conv1d37_out1 = self.conv1d37.forward(transpose53_out1);
        let split_tensors = conv1d37_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split13_out1, split13_out2] = split_tensors.try_into().unwrap();
        let sigmoid50_out1 = burn::tensor::activation::sigmoid(split13_out2);
        let mul88_out1 = split13_out1.mul(sigmoid50_out1);
        let conv1d38_out1 = self.conv1d38.forward(mul88_out1);
        let sigmoid51_out1 = burn::tensor::activation::sigmoid(conv1d38_out1.clone());
        let mul89_out1 = conv1d38_out1.mul(sigmoid51_out1);
        let conv1d39_out1 = self.conv1d39.forward(mul89_out1);
        let transpose54_out1 = conv1d39_out1.permute([0, 2, 1]);
        let add77_out1 = add76_out1.add(transpose54_out1);
        let layernormalization64_out1 = {
            let dtype = add77_out1.clone().dtype();
            self.layernormalization64
                .forward(add77_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear117_out1 = self.linear117.forward(layernormalization64_out1);
        let sigmoid52_out1 = burn::tensor::activation::sigmoid(linear117_out1.clone());
        let mul90_out1 = linear117_out1.mul(sigmoid52_out1);
        let linear118_out1 = self.linear118.forward(mul90_out1);
        let constant1925_out1 = self.constant1925.val();
        let mul91_out1 = linear118_out1
            .mul((constant1925_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add78_out1 = add77_out1.add(mul91_out1);
        add78_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule12 {
    layernormalization65: LayerNorm,
    layernormalization66: LayerNorm,
    linear119: Linear,
    linear120: Linear,
    constant1926: burn::module::Param<Tensor<1>>,
    layernormalization67: LayerNorm,
    linear121: Linear,
    linear122: Linear,
    linear123: Linear,
    constant483: burn::module::Param<Tensor<1>>,
    constant484: burn::module::Param<Tensor<4>>,
    linear124: Linear,
    constant1940: burn::module::Param<Tensor<1>>,
    linear125: Linear,
    layernormalization68: LayerNorm,
    conv1d40: Conv1d,
    conv1d41: Conv1d,
    conv1d42: Conv1d,
    layernormalization69: LayerNorm,
    linear126: Linear,
    linear127: Linear,
    constant1942: burn::module::Param<Tensor<1>>,
    layernormalization70: LayerNorm,
    layernormalization71: LayerNorm,
    linear128: Linear,
    linear129: Linear,
    constant1943: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule12 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization65 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization66 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear119 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear120 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1926: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization67 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear121 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear122 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear123 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant483: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant484: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear124 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1940: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear125 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization68 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d40 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d41 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d42 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization69 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear126 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear127 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1942: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization70 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization71 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear128 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear129 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1943: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization65,
            layernormalization66,
            linear119,
            linear120,
            constant1926,
            layernormalization67,
            linear121,
            linear122,
            linear123,
            constant483,
            constant484,
            linear124,
            constant1940,
            linear125,
            layernormalization68,
            conv1d40,
            conv1d41,
            conv1d42,
            layernormalization69,
            linear126,
            linear127,
            constant1942,
            layernormalization70,
            layernormalization71,
            linear128,
            linear129,
            constant1943,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add78_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization65_out1 = {
            let dtype = add78_out1.dtype();
            self.layernormalization65
                .forward(add78_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization66_out1 = {
            let dtype = layernormalization65_out1.clone().dtype();
            self.layernormalization66
                .forward(
                    layernormalization65_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear119_out1 = self.linear119.forward(layernormalization66_out1);
        let sigmoid53_out1 = burn::tensor::activation::sigmoid(linear119_out1.clone());
        let mul92_out1 = linear119_out1.mul(sigmoid53_out1);
        let linear120_out1 = self.linear120.forward(mul92_out1);
        let constant1926_out1 = self.constant1926.val();
        let mul93_out1 = linear120_out1
            .mul((constant1926_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add79_out1 = layernormalization65_out1.add(mul93_out1);
        let layernormalization67_out1 = {
            let dtype = add79_out1.clone().dtype();
            self.layernormalization67
                .forward(add79_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear121_out1 = self.linear121.forward(layernormalization67_out1.clone());
        let linear122_out1 = self.linear122.forward(layernormalization67_out1.clone());
        let linear123_out1 = self.linear123.forward(layernormalization67_out1);
        let constant483_out1 = self.constant483.val();
        let add80_out1 = linear121_out1
            .clone()
            .add((constant483_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape55_out1 = linear121_out1.reshape([0, -1, 8, 160]);
        let transpose55_out1 = reshape55_out1.permute([0, 2, 1, 3]);
        let constant484_out1 = self.constant484.val();
        let add81_out1 = transpose55_out1.clone().add(constant484_out1);
        let linear124_out1 = self.linear124.forward(reshape2_out1);
        let reshape56_out1 = linear124_out1.reshape([0, -1, 8, 160]);
        let transpose56_out1 = reshape56_out1.permute([0, 2, 3, 1]);
        let matmul139_out1 = add81_out1.matmul(transpose56_out1);
        let pad14_out1 = matmul139_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape15_out1: [i64; 4] = {
            let axes = &transpose55_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather15_out1 = shape15_out1[2] as i64;
        let unsqueeze18_out1 = [gather15_out1 as i64];
        let constant1932_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat28_out1: [i64; 4usize] = [
            &constant1932_out1[..],
            &unsqueeze18_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape57_out1 = pad14_out1.reshape(concat28_out1);
        let slice27_out1 = reshape57_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1936_out1: [i64; 2] = [0i64, 0i64];
        let constant1937_out1: [i64; 1] = [-1i64];
        let concat29_out1: [i64; 4usize] = [
            &constant1936_out1[..],
            &unsqueeze18_out1[..],
            &constant1937_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape58_out1 = slice27_out1.reshape(concat29_out1);
        let slice28_out1 = reshape58_out1.slice(s![.., .., .., 0..unsqueeze18_out1[0]]);
        let constant1940_out1 = self.constant1940.val();
        let mul94_out1 = slice28_out1
            .mul((constant1940_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention14_out1,) = {
            let q = add80_out1;
            let k = linear122_out1;
            let v = linear123_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul94_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention14_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention14_out1 = {
                let dims = attention14_out1.dims();
                attention14_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention14_out1 = attention14_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention14_out1,)
        };
        let linear125_out1 = self.linear125.forward(attention14_out1);
        let add82_out1 = add79_out1.add(linear125_out1);
        let layernormalization68_out1 = {
            let dtype = add82_out1.clone().dtype();
            self.layernormalization68
                .forward(add82_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose57_out1 = layernormalization68_out1.permute([0, 2, 1]);
        let conv1d40_out1 = self.conv1d40.forward(transpose57_out1);
        let split_tensors = conv1d40_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split14_out1, split14_out2] = split_tensors.try_into().unwrap();
        let sigmoid54_out1 = burn::tensor::activation::sigmoid(split14_out2);
        let mul95_out1 = split14_out1.mul(sigmoid54_out1);
        let conv1d41_out1 = self.conv1d41.forward(mul95_out1);
        let sigmoid55_out1 = burn::tensor::activation::sigmoid(conv1d41_out1.clone());
        let mul96_out1 = conv1d41_out1.mul(sigmoid55_out1);
        let conv1d42_out1 = self.conv1d42.forward(mul96_out1);
        let transpose58_out1 = conv1d42_out1.permute([0, 2, 1]);
        let add83_out1 = add82_out1.add(transpose58_out1);
        let layernormalization69_out1 = {
            let dtype = add83_out1.clone().dtype();
            self.layernormalization69
                .forward(add83_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear126_out1 = self.linear126.forward(layernormalization69_out1);
        let sigmoid56_out1 = burn::tensor::activation::sigmoid(linear126_out1.clone());
        let mul97_out1 = linear126_out1.mul(sigmoid56_out1);
        let linear127_out1 = self.linear127.forward(mul97_out1);
        let constant1942_out1 = self.constant1942.val();
        let mul98_out1 = linear127_out1
            .mul((constant1942_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add84_out1 = add83_out1.add(mul98_out1);
        let layernormalization70_out1 = {
            let dtype = add84_out1.dtype();
            self.layernormalization70
                .forward(add84_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization71_out1 = {
            let dtype = layernormalization70_out1.clone().dtype();
            self.layernormalization71
                .forward(
                    layernormalization70_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear128_out1 = self.linear128.forward(layernormalization71_out1);
        let sigmoid57_out1 = burn::tensor::activation::sigmoid(linear128_out1.clone());
        let mul99_out1 = linear128_out1.mul(sigmoid57_out1);
        let linear129_out1 = self.linear129.forward(mul99_out1);
        let constant1943_out1 = self.constant1943.val();
        let mul100_out1 = linear129_out1
            .mul((constant1943_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add85_out1 = layernormalization70_out1.add(mul100_out1);
        add85_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule13 {
    layernormalization72: LayerNorm,
    linear130: Linear,
    linear131: Linear,
    linear132: Linear,
    constant518: burn::module::Param<Tensor<1>>,
    constant519: burn::module::Param<Tensor<4>>,
    linear133: Linear,
    constant1957: burn::module::Param<Tensor<1>>,
    linear134: Linear,
    layernormalization73: LayerNorm,
    conv1d43: Conv1d,
    conv1d44: Conv1d,
    conv1d45: Conv1d,
    layernormalization74: LayerNorm,
    linear135: Linear,
    linear136: Linear,
    constant1959: burn::module::Param<Tensor<1>>,
    layernormalization75: LayerNorm,
    layernormalization76: LayerNorm,
    linear137: Linear,
    linear138: Linear,
    constant1960: burn::module::Param<Tensor<1>>,
    layernormalization77: LayerNorm,
    linear139: Linear,
    linear140: Linear,
    linear141: Linear,
    constant553: burn::module::Param<Tensor<1>>,
    constant554: burn::module::Param<Tensor<4>>,
    linear142: Linear,
    constant1974: burn::module::Param<Tensor<1>>,
    linear143: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule13 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization72 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear130 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear131 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear132 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant518: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant519: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear133 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1957: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear134 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization73 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d43 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d44 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d45 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization74 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear135 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear136 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1959: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization75 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization76 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear137 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear138 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1960: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization77 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear139 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear140 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear141 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant553: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant554: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear142 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1974: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear143 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization72,
            linear130,
            linear131,
            linear132,
            constant518,
            constant519,
            linear133,
            constant1957,
            linear134,
            layernormalization73,
            conv1d43,
            conv1d44,
            conv1d45,
            layernormalization74,
            linear135,
            linear136,
            constant1959,
            layernormalization75,
            layernormalization76,
            linear137,
            linear138,
            constant1960,
            layernormalization77,
            linear139,
            linear140,
            linear141,
            constant553,
            constant554,
            linear142,
            constant1974,
            linear143,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add85_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization72_out1 = {
            let dtype = add85_out1.clone().dtype();
            self.layernormalization72
                .forward(add85_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear130_out1 = self.linear130.forward(layernormalization72_out1.clone());
        let linear131_out1 = self.linear131.forward(layernormalization72_out1.clone());
        let linear132_out1 = self.linear132.forward(layernormalization72_out1);
        let constant518_out1 = self.constant518.val();
        let add86_out1 = linear130_out1
            .clone()
            .add((constant518_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape59_out1 = linear130_out1.reshape([0, -1, 8, 160]);
        let transpose59_out1 = reshape59_out1.permute([0, 2, 1, 3]);
        let constant519_out1 = self.constant519.val();
        let add87_out1 = transpose59_out1.clone().add(constant519_out1);
        let linear133_out1 = self.linear133.forward(reshape2_out1.clone());
        let reshape60_out1 = linear133_out1.reshape([0, -1, 8, 160]);
        let transpose60_out1 = reshape60_out1.permute([0, 2, 3, 1]);
        let matmul149_out1 = add87_out1.matmul(transpose60_out1);
        let pad15_out1 = matmul149_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape16_out1: [i64; 4] = {
            let axes = &transpose59_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather16_out1 = shape16_out1[2] as i64;
        let unsqueeze19_out1 = [gather16_out1 as i64];
        let constant1949_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat30_out1: [i64; 4usize] = [
            &constant1949_out1[..],
            &unsqueeze19_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape61_out1 = pad15_out1.reshape(concat30_out1);
        let slice29_out1 = reshape61_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1953_out1: [i64; 2] = [0i64, 0i64];
        let constant1954_out1: [i64; 1] = [-1i64];
        let concat31_out1: [i64; 4usize] = [
            &constant1953_out1[..],
            &unsqueeze19_out1[..],
            &constant1954_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape62_out1 = slice29_out1.reshape(concat31_out1);
        let slice30_out1 = reshape62_out1.slice(s![.., .., .., 0..unsqueeze19_out1[0]]);
        let constant1957_out1 = self.constant1957.val();
        let mul101_out1 = slice30_out1
            .mul((constant1957_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention15_out1,) = {
            let q = add86_out1;
            let k = linear131_out1;
            let v = linear132_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul101_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention15_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention15_out1 = {
                let dims = attention15_out1.dims();
                attention15_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention15_out1 = attention15_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention15_out1,)
        };
        let linear134_out1 = self.linear134.forward(attention15_out1);
        let add88_out1 = add85_out1.add(linear134_out1);
        let layernormalization73_out1 = {
            let dtype = add88_out1.clone().dtype();
            self.layernormalization73
                .forward(add88_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose61_out1 = layernormalization73_out1.permute([0, 2, 1]);
        let conv1d43_out1 = self.conv1d43.forward(transpose61_out1);
        let split_tensors = conv1d43_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split15_out1, split15_out2] = split_tensors.try_into().unwrap();
        let sigmoid58_out1 = burn::tensor::activation::sigmoid(split15_out2);
        let mul102_out1 = split15_out1.mul(sigmoid58_out1);
        let conv1d44_out1 = self.conv1d44.forward(mul102_out1);
        let sigmoid59_out1 = burn::tensor::activation::sigmoid(conv1d44_out1.clone());
        let mul103_out1 = conv1d44_out1.mul(sigmoid59_out1);
        let conv1d45_out1 = self.conv1d45.forward(mul103_out1);
        let transpose62_out1 = conv1d45_out1.permute([0, 2, 1]);
        let add89_out1 = add88_out1.add(transpose62_out1);
        let layernormalization74_out1 = {
            let dtype = add89_out1.clone().dtype();
            self.layernormalization74
                .forward(add89_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear135_out1 = self.linear135.forward(layernormalization74_out1);
        let sigmoid60_out1 = burn::tensor::activation::sigmoid(linear135_out1.clone());
        let mul104_out1 = linear135_out1.mul(sigmoid60_out1);
        let linear136_out1 = self.linear136.forward(mul104_out1);
        let constant1959_out1 = self.constant1959.val();
        let mul105_out1 = linear136_out1
            .mul((constant1959_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add90_out1 = add89_out1.add(mul105_out1);
        let layernormalization75_out1 = {
            let dtype = add90_out1.dtype();
            self.layernormalization75
                .forward(add90_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization76_out1 = {
            let dtype = layernormalization75_out1.clone().dtype();
            self.layernormalization76
                .forward(
                    layernormalization75_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear137_out1 = self.linear137.forward(layernormalization76_out1);
        let sigmoid61_out1 = burn::tensor::activation::sigmoid(linear137_out1.clone());
        let mul106_out1 = linear137_out1.mul(sigmoid61_out1);
        let linear138_out1 = self.linear138.forward(mul106_out1);
        let constant1960_out1 = self.constant1960.val();
        let mul107_out1 = linear138_out1
            .mul((constant1960_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add91_out1 = layernormalization75_out1.add(mul107_out1);
        let layernormalization77_out1 = {
            let dtype = add91_out1.clone().dtype();
            self.layernormalization77
                .forward(add91_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear139_out1 = self.linear139.forward(layernormalization77_out1.clone());
        let linear140_out1 = self.linear140.forward(layernormalization77_out1.clone());
        let linear141_out1 = self.linear141.forward(layernormalization77_out1);
        let constant553_out1 = self.constant553.val();
        let add92_out1 = linear139_out1
            .clone()
            .add((constant553_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape63_out1 = linear139_out1.reshape([0, -1, 8, 160]);
        let transpose63_out1 = reshape63_out1.permute([0, 2, 1, 3]);
        let constant554_out1 = self.constant554.val();
        let add93_out1 = transpose63_out1.clone().add(constant554_out1);
        let linear142_out1 = self.linear142.forward(reshape2_out1);
        let reshape64_out1 = linear142_out1.reshape([0, -1, 8, 160]);
        let transpose64_out1 = reshape64_out1.permute([0, 2, 3, 1]);
        let matmul159_out1 = add93_out1.matmul(transpose64_out1);
        let pad16_out1 = matmul159_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape17_out1: [i64; 4] = {
            let axes = &transpose63_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather17_out1 = shape17_out1[2] as i64;
        let unsqueeze20_out1 = [gather17_out1 as i64];
        let constant1966_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat32_out1: [i64; 4usize] = [
            &constant1966_out1[..],
            &unsqueeze20_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape65_out1 = pad16_out1.reshape(concat32_out1);
        let slice31_out1 = reshape65_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1970_out1: [i64; 2] = [0i64, 0i64];
        let constant1971_out1: [i64; 1] = [-1i64];
        let concat33_out1: [i64; 4usize] = [
            &constant1970_out1[..],
            &unsqueeze20_out1[..],
            &constant1971_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape66_out1 = slice31_out1.reshape(concat33_out1);
        let slice32_out1 = reshape66_out1.slice(s![.., .., .., 0..unsqueeze20_out1[0]]);
        let constant1974_out1 = self.constant1974.val();
        let mul108_out1 = slice32_out1
            .mul((constant1974_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention16_out1,) = {
            let q = add92_out1;
            let k = linear140_out1;
            let v = linear141_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul108_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention16_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention16_out1 = {
                let dims = attention16_out1.dims();
                attention16_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention16_out1 = attention16_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention16_out1,)
        };
        let linear143_out1 = self.linear143.forward(attention16_out1);
        let add94_out1 = add91_out1.add(linear143_out1);
        add94_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule14 {
    layernormalization78: LayerNorm,
    conv1d46: Conv1d,
    conv1d47: Conv1d,
    conv1d48: Conv1d,
    layernormalization79: LayerNorm,
    linear144: Linear,
    linear145: Linear,
    constant1976: burn::module::Param<Tensor<1>>,
    layernormalization80: LayerNorm,
    layernormalization81: LayerNorm,
    linear146: Linear,
    linear147: Linear,
    constant1977: burn::module::Param<Tensor<1>>,
    layernormalization82: LayerNorm,
    linear148: Linear,
    linear149: Linear,
    linear150: Linear,
    constant588: burn::module::Param<Tensor<1>>,
    constant589: burn::module::Param<Tensor<4>>,
    linear151: Linear,
    constant1991: burn::module::Param<Tensor<1>>,
    linear152: Linear,
    layernormalization83: LayerNorm,
    conv1d49: Conv1d,
    conv1d50: Conv1d,
    conv1d51: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule14 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization78 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d46 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d47 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d48 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization79 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear144 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear145 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1976: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization80 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization81 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear146 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear147 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1977: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization82 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear148 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear149 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear150 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant588: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant589: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear151 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant1991: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear152 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization83 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d49 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d50 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d51 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization78,
            conv1d46,
            conv1d47,
            conv1d48,
            layernormalization79,
            linear144,
            linear145,
            constant1976,
            layernormalization80,
            layernormalization81,
            linear146,
            linear147,
            constant1977,
            layernormalization82,
            linear148,
            linear149,
            linear150,
            constant588,
            constant589,
            linear151,
            constant1991,
            linear152,
            layernormalization83,
            conv1d49,
            conv1d50,
            conv1d51,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, add94_out1: Tensor<3>, reshape2_out1: Tensor<3>) -> Tensor<3> {
        let layernormalization78_out1 = {
            let dtype = add94_out1.clone().dtype();
            self.layernormalization78
                .forward(add94_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose65_out1 = layernormalization78_out1.permute([0, 2, 1]);
        let conv1d46_out1 = self.conv1d46.forward(transpose65_out1);
        let split_tensors = conv1d46_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split16_out1, split16_out2] = split_tensors.try_into().unwrap();
        let sigmoid62_out1 = burn::tensor::activation::sigmoid(split16_out2);
        let mul109_out1 = split16_out1.mul(sigmoid62_out1);
        let conv1d47_out1 = self.conv1d47.forward(mul109_out1);
        let sigmoid63_out1 = burn::tensor::activation::sigmoid(conv1d47_out1.clone());
        let mul110_out1 = conv1d47_out1.mul(sigmoid63_out1);
        let conv1d48_out1 = self.conv1d48.forward(mul110_out1);
        let transpose66_out1 = conv1d48_out1.permute([0, 2, 1]);
        let add95_out1 = add94_out1.add(transpose66_out1);
        let layernormalization79_out1 = {
            let dtype = add95_out1.clone().dtype();
            self.layernormalization79
                .forward(add95_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear144_out1 = self.linear144.forward(layernormalization79_out1);
        let sigmoid64_out1 = burn::tensor::activation::sigmoid(linear144_out1.clone());
        let mul111_out1 = linear144_out1.mul(sigmoid64_out1);
        let linear145_out1 = self.linear145.forward(mul111_out1);
        let constant1976_out1 = self.constant1976.val();
        let mul112_out1 = linear145_out1
            .mul((constant1976_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add96_out1 = add95_out1.add(mul112_out1);
        let layernormalization80_out1 = {
            let dtype = add96_out1.dtype();
            self.layernormalization80
                .forward(add96_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization81_out1 = {
            let dtype = layernormalization80_out1.clone().dtype();
            self.layernormalization81
                .forward(
                    layernormalization80_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear146_out1 = self.linear146.forward(layernormalization81_out1);
        let sigmoid65_out1 = burn::tensor::activation::sigmoid(linear146_out1.clone());
        let mul113_out1 = linear146_out1.mul(sigmoid65_out1);
        let linear147_out1 = self.linear147.forward(mul113_out1);
        let constant1977_out1 = self.constant1977.val();
        let mul114_out1 = linear147_out1
            .mul((constant1977_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add97_out1 = layernormalization80_out1.add(mul114_out1);
        let layernormalization82_out1 = {
            let dtype = add97_out1.clone().dtype();
            self.layernormalization82
                .forward(add97_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear148_out1 = self.linear148.forward(layernormalization82_out1.clone());
        let linear149_out1 = self.linear149.forward(layernormalization82_out1.clone());
        let linear150_out1 = self.linear150.forward(layernormalization82_out1);
        let constant588_out1 = self.constant588.val();
        let add98_out1 = linear148_out1
            .clone()
            .add((constant588_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape67_out1 = linear148_out1.reshape([0, -1, 8, 160]);
        let transpose67_out1 = reshape67_out1.permute([0, 2, 1, 3]);
        let constant589_out1 = self.constant589.val();
        let add99_out1 = transpose67_out1.clone().add(constant589_out1);
        let linear151_out1 = self.linear151.forward(reshape2_out1);
        let reshape68_out1 = linear151_out1.reshape([0, -1, 8, 160]);
        let transpose68_out1 = reshape68_out1.permute([0, 2, 3, 1]);
        let matmul169_out1 = add99_out1.matmul(transpose68_out1);
        let pad17_out1 = matmul169_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape18_out1: [i64; 4] = {
            let axes = &transpose67_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather18_out1 = shape18_out1[2] as i64;
        let unsqueeze21_out1 = [gather18_out1 as i64];
        let constant1983_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat34_out1: [i64; 4usize] = [
            &constant1983_out1[..],
            &unsqueeze21_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape69_out1 = pad17_out1.reshape(concat34_out1);
        let slice33_out1 = reshape69_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant1987_out1: [i64; 2] = [0i64, 0i64];
        let constant1988_out1: [i64; 1] = [-1i64];
        let concat35_out1: [i64; 4usize] = [
            &constant1987_out1[..],
            &unsqueeze21_out1[..],
            &constant1988_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape70_out1 = slice33_out1.reshape(concat35_out1);
        let slice34_out1 = reshape70_out1.slice(s![.., .., .., 0..unsqueeze21_out1[0]]);
        let constant1991_out1 = self.constant1991.val();
        let mul115_out1 = slice34_out1
            .mul((constant1991_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention17_out1,) = {
            let q = add98_out1;
            let k = linear149_out1;
            let v = linear150_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul115_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention17_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention17_out1 = {
                let dims = attention17_out1.dims();
                attention17_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention17_out1 = attention17_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention17_out1,)
        };
        let linear152_out1 = self.linear152.forward(attention17_out1);
        let add100_out1 = add97_out1.add(linear152_out1);
        let layernormalization83_out1 = {
            let dtype = add100_out1.clone().dtype();
            self.layernormalization83
                .forward(add100_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose69_out1 = layernormalization83_out1.permute([0, 2, 1]);
        let conv1d49_out1 = self.conv1d49.forward(transpose69_out1);
        let split_tensors = conv1d49_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split17_out1, split17_out2] = split_tensors.try_into().unwrap();
        let sigmoid66_out1 = burn::tensor::activation::sigmoid(split17_out2);
        let mul116_out1 = split17_out1.mul(sigmoid66_out1);
        let conv1d50_out1 = self.conv1d50.forward(mul116_out1);
        let sigmoid67_out1 = burn::tensor::activation::sigmoid(conv1d50_out1.clone());
        let mul117_out1 = conv1d50_out1.mul(sigmoid67_out1);
        let conv1d51_out1 = self.conv1d51.forward(mul117_out1);
        let transpose70_out1 = conv1d51_out1.permute([0, 2, 1]);
        let add101_out1 = add100_out1.add(transpose70_out1);
        add101_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule15 {
    layernormalization84: LayerNorm,
    linear153: Linear,
    linear154: Linear,
    constant1993: burn::module::Param<Tensor<1>>,
    layernormalization85: LayerNorm,
    layernormalization86: LayerNorm,
    linear155: Linear,
    linear156: Linear,
    constant1994: burn::module::Param<Tensor<1>>,
    layernormalization87: LayerNorm,
    linear157: Linear,
    linear158: Linear,
    linear159: Linear,
    constant623: burn::module::Param<Tensor<1>>,
    constant624: burn::module::Param<Tensor<4>>,
    linear160: Linear,
    constant2008: burn::module::Param<Tensor<1>>,
    linear161: Linear,
    layernormalization88: LayerNorm,
    conv1d52: Conv1d,
    conv1d53: Conv1d,
    conv1d54: Conv1d,
    layernormalization89: LayerNorm,
    linear162: Linear,
    linear163: Linear,
    constant2010: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule15 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization84 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear153 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear154 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1993: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization85 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization86 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear155 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear156 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant1994: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization87 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear157 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear158 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear159 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant623: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant624: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear160 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2008: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear161 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization88 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d52 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d53 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d54 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization89 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear162 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear163 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2010: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization84,
            linear153,
            linear154,
            constant1993,
            layernormalization85,
            layernormalization86,
            linear155,
            linear156,
            constant1994,
            layernormalization87,
            linear157,
            linear158,
            linear159,
            constant623,
            constant624,
            linear160,
            constant2008,
            linear161,
            layernormalization88,
            conv1d52,
            conv1d53,
            conv1d54,
            layernormalization89,
            linear162,
            linear163,
            constant2010,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add101_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization84_out1 = {
            let dtype = add101_out1.clone().dtype();
            self.layernormalization84
                .forward(add101_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear153_out1 = self.linear153.forward(layernormalization84_out1);
        let sigmoid68_out1 = burn::tensor::activation::sigmoid(linear153_out1.clone());
        let mul118_out1 = linear153_out1.mul(sigmoid68_out1);
        let linear154_out1 = self.linear154.forward(mul118_out1);
        let constant1993_out1 = self.constant1993.val();
        let mul119_out1 = linear154_out1
            .mul((constant1993_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add102_out1 = add101_out1.add(mul119_out1);
        let layernormalization85_out1 = {
            let dtype = add102_out1.dtype();
            self.layernormalization85
                .forward(add102_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization86_out1 = {
            let dtype = layernormalization85_out1.clone().dtype();
            self.layernormalization86
                .forward(
                    layernormalization85_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear155_out1 = self.linear155.forward(layernormalization86_out1);
        let sigmoid69_out1 = burn::tensor::activation::sigmoid(linear155_out1.clone());
        let mul120_out1 = linear155_out1.mul(sigmoid69_out1);
        let linear156_out1 = self.linear156.forward(mul120_out1);
        let constant1994_out1 = self.constant1994.val();
        let mul121_out1 = linear156_out1
            .mul((constant1994_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add103_out1 = layernormalization85_out1.add(mul121_out1);
        let layernormalization87_out1 = {
            let dtype = add103_out1.clone().dtype();
            self.layernormalization87
                .forward(add103_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear157_out1 = self.linear157.forward(layernormalization87_out1.clone());
        let linear158_out1 = self.linear158.forward(layernormalization87_out1.clone());
        let linear159_out1 = self.linear159.forward(layernormalization87_out1);
        let constant623_out1 = self.constant623.val();
        let add104_out1 = linear157_out1
            .clone()
            .add((constant623_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape71_out1 = linear157_out1.reshape([0, -1, 8, 160]);
        let transpose71_out1 = reshape71_out1.permute([0, 2, 1, 3]);
        let constant624_out1 = self.constant624.val();
        let add105_out1 = transpose71_out1.clone().add(constant624_out1);
        let linear160_out1 = self.linear160.forward(reshape2_out1);
        let reshape72_out1 = linear160_out1.reshape([0, -1, 8, 160]);
        let transpose72_out1 = reshape72_out1.permute([0, 2, 3, 1]);
        let matmul179_out1 = add105_out1.matmul(transpose72_out1);
        let pad18_out1 = matmul179_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape19_out1: [i64; 4] = {
            let axes = &transpose71_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather19_out1 = shape19_out1[2] as i64;
        let unsqueeze22_out1 = [gather19_out1 as i64];
        let constant2000_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat36_out1: [i64; 4usize] = [
            &constant2000_out1[..],
            &unsqueeze22_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape73_out1 = pad18_out1.reshape(concat36_out1);
        let slice35_out1 = reshape73_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2004_out1: [i64; 2] = [0i64, 0i64];
        let constant2005_out1: [i64; 1] = [-1i64];
        let concat37_out1: [i64; 4usize] = [
            &constant2004_out1[..],
            &unsqueeze22_out1[..],
            &constant2005_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape74_out1 = slice35_out1.reshape(concat37_out1);
        let slice36_out1 = reshape74_out1.slice(s![.., .., .., 0..unsqueeze22_out1[0]]);
        let constant2008_out1 = self.constant2008.val();
        let mul122_out1 = slice36_out1
            .mul((constant2008_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention18_out1,) = {
            let q = add104_out1;
            let k = linear158_out1;
            let v = linear159_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul122_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention18_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention18_out1 = {
                let dims = attention18_out1.dims();
                attention18_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention18_out1 = attention18_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention18_out1,)
        };
        let linear161_out1 = self.linear161.forward(attention18_out1);
        let add106_out1 = add103_out1.add(linear161_out1);
        let layernormalization88_out1 = {
            let dtype = add106_out1.clone().dtype();
            self.layernormalization88
                .forward(add106_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose73_out1 = layernormalization88_out1.permute([0, 2, 1]);
        let conv1d52_out1 = self.conv1d52.forward(transpose73_out1);
        let split_tensors = conv1d52_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split18_out1, split18_out2] = split_tensors.try_into().unwrap();
        let sigmoid70_out1 = burn::tensor::activation::sigmoid(split18_out2);
        let mul123_out1 = split18_out1.mul(sigmoid70_out1);
        let conv1d53_out1 = self.conv1d53.forward(mul123_out1);
        let sigmoid71_out1 = burn::tensor::activation::sigmoid(conv1d53_out1.clone());
        let mul124_out1 = conv1d53_out1.mul(sigmoid71_out1);
        let conv1d54_out1 = self.conv1d54.forward(mul124_out1);
        let transpose74_out1 = conv1d54_out1.permute([0, 2, 1]);
        let add107_out1 = add106_out1.add(transpose74_out1);
        let layernormalization89_out1 = {
            let dtype = add107_out1.clone().dtype();
            self.layernormalization89
                .forward(add107_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear162_out1 = self.linear162.forward(layernormalization89_out1);
        let sigmoid72_out1 = burn::tensor::activation::sigmoid(linear162_out1.clone());
        let mul125_out1 = linear162_out1.mul(sigmoid72_out1);
        let linear163_out1 = self.linear163.forward(mul125_out1);
        let constant2010_out1 = self.constant2010.val();
        let mul126_out1 = linear163_out1
            .mul((constant2010_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add108_out1 = add107_out1.add(mul126_out1);
        add108_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule16 {
    layernormalization90: LayerNorm,
    layernormalization91: LayerNorm,
    linear164: Linear,
    linear165: Linear,
    constant2011: burn::module::Param<Tensor<1>>,
    layernormalization92: LayerNorm,
    linear166: Linear,
    linear167: Linear,
    linear168: Linear,
    constant658: burn::module::Param<Tensor<1>>,
    constant659: burn::module::Param<Tensor<4>>,
    linear169: Linear,
    constant2025: burn::module::Param<Tensor<1>>,
    linear170: Linear,
    layernormalization93: LayerNorm,
    conv1d55: Conv1d,
    conv1d56: Conv1d,
    conv1d57: Conv1d,
    layernormalization94: LayerNorm,
    linear171: Linear,
    linear172: Linear,
    constant2027: burn::module::Param<Tensor<1>>,
    layernormalization95: LayerNorm,
    layernormalization96: LayerNorm,
    linear173: Linear,
    linear174: Linear,
    constant2028: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule16 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization90 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization91 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear164 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear165 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2011: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization92 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear166 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear167 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear168 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant658: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant659: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear169 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2025: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear170 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization93 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d55 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d56 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d57 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization94 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear171 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear172 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2027: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization95 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization96 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear173 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear174 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2028: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization90,
            layernormalization91,
            linear164,
            linear165,
            constant2011,
            layernormalization92,
            linear166,
            linear167,
            linear168,
            constant658,
            constant659,
            linear169,
            constant2025,
            linear170,
            layernormalization93,
            conv1d55,
            conv1d56,
            conv1d57,
            layernormalization94,
            linear171,
            linear172,
            constant2027,
            layernormalization95,
            layernormalization96,
            linear173,
            linear174,
            constant2028,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add108_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization90_out1 = {
            let dtype = add108_out1.dtype();
            self.layernormalization90
                .forward(add108_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization91_out1 = {
            let dtype = layernormalization90_out1.clone().dtype();
            self.layernormalization91
                .forward(
                    layernormalization90_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear164_out1 = self.linear164.forward(layernormalization91_out1);
        let sigmoid73_out1 = burn::tensor::activation::sigmoid(linear164_out1.clone());
        let mul127_out1 = linear164_out1.mul(sigmoid73_out1);
        let linear165_out1 = self.linear165.forward(mul127_out1);
        let constant2011_out1 = self.constant2011.val();
        let mul128_out1 = linear165_out1
            .mul((constant2011_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add109_out1 = layernormalization90_out1.add(mul128_out1);
        let layernormalization92_out1 = {
            let dtype = add109_out1.clone().dtype();
            self.layernormalization92
                .forward(add109_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear166_out1 = self.linear166.forward(layernormalization92_out1.clone());
        let linear167_out1 = self.linear167.forward(layernormalization92_out1.clone());
        let linear168_out1 = self.linear168.forward(layernormalization92_out1);
        let constant658_out1 = self.constant658.val();
        let add110_out1 = linear166_out1
            .clone()
            .add((constant658_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape75_out1 = linear166_out1.reshape([0, -1, 8, 160]);
        let transpose75_out1 = reshape75_out1.permute([0, 2, 1, 3]);
        let constant659_out1 = self.constant659.val();
        let add111_out1 = transpose75_out1.clone().add(constant659_out1);
        let linear169_out1 = self.linear169.forward(reshape2_out1);
        let reshape76_out1 = linear169_out1.reshape([0, -1, 8, 160]);
        let transpose76_out1 = reshape76_out1.permute([0, 2, 3, 1]);
        let matmul189_out1 = add111_out1.matmul(transpose76_out1);
        let pad19_out1 = matmul189_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape20_out1: [i64; 4] = {
            let axes = &transpose75_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather20_out1 = shape20_out1[2] as i64;
        let unsqueeze23_out1 = [gather20_out1 as i64];
        let constant2017_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat38_out1: [i64; 4usize] = [
            &constant2017_out1[..],
            &unsqueeze23_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape77_out1 = pad19_out1.reshape(concat38_out1);
        let slice37_out1 = reshape77_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2021_out1: [i64; 2] = [0i64, 0i64];
        let constant2022_out1: [i64; 1] = [-1i64];
        let concat39_out1: [i64; 4usize] = [
            &constant2021_out1[..],
            &unsqueeze23_out1[..],
            &constant2022_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape78_out1 = slice37_out1.reshape(concat39_out1);
        let slice38_out1 = reshape78_out1.slice(s![.., .., .., 0..unsqueeze23_out1[0]]);
        let constant2025_out1 = self.constant2025.val();
        let mul129_out1 = slice38_out1
            .mul((constant2025_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention19_out1,) = {
            let q = add110_out1;
            let k = linear167_out1;
            let v = linear168_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul129_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention19_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention19_out1 = {
                let dims = attention19_out1.dims();
                attention19_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention19_out1 = attention19_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention19_out1,)
        };
        let linear170_out1 = self.linear170.forward(attention19_out1);
        let add112_out1 = add109_out1.add(linear170_out1);
        let layernormalization93_out1 = {
            let dtype = add112_out1.clone().dtype();
            self.layernormalization93
                .forward(add112_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose77_out1 = layernormalization93_out1.permute([0, 2, 1]);
        let conv1d55_out1 = self.conv1d55.forward(transpose77_out1);
        let split_tensors = conv1d55_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split19_out1, split19_out2] = split_tensors.try_into().unwrap();
        let sigmoid74_out1 = burn::tensor::activation::sigmoid(split19_out2);
        let mul130_out1 = split19_out1.mul(sigmoid74_out1);
        let conv1d56_out1 = self.conv1d56.forward(mul130_out1);
        let sigmoid75_out1 = burn::tensor::activation::sigmoid(conv1d56_out1.clone());
        let mul131_out1 = conv1d56_out1.mul(sigmoid75_out1);
        let conv1d57_out1 = self.conv1d57.forward(mul131_out1);
        let transpose78_out1 = conv1d57_out1.permute([0, 2, 1]);
        let add113_out1 = add112_out1.add(transpose78_out1);
        let layernormalization94_out1 = {
            let dtype = add113_out1.clone().dtype();
            self.layernormalization94
                .forward(add113_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear171_out1 = self.linear171.forward(layernormalization94_out1);
        let sigmoid76_out1 = burn::tensor::activation::sigmoid(linear171_out1.clone());
        let mul132_out1 = linear171_out1.mul(sigmoid76_out1);
        let linear172_out1 = self.linear172.forward(mul132_out1);
        let constant2027_out1 = self.constant2027.val();
        let mul133_out1 = linear172_out1
            .mul((constant2027_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add114_out1 = add113_out1.add(mul133_out1);
        let layernormalization95_out1 = {
            let dtype = add114_out1.dtype();
            self.layernormalization95
                .forward(add114_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization96_out1 = {
            let dtype = layernormalization95_out1.clone().dtype();
            self.layernormalization96
                .forward(
                    layernormalization95_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear173_out1 = self.linear173.forward(layernormalization96_out1);
        let sigmoid77_out1 = burn::tensor::activation::sigmoid(linear173_out1.clone());
        let mul134_out1 = linear173_out1.mul(sigmoid77_out1);
        let linear174_out1 = self.linear174.forward(mul134_out1);
        let constant2028_out1 = self.constant2028.val();
        let mul135_out1 = linear174_out1
            .mul((constant2028_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add115_out1 = layernormalization95_out1.add(mul135_out1);
        add115_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule17 {
    layernormalization97: LayerNorm,
    linear175: Linear,
    linear176: Linear,
    linear177: Linear,
    constant693: burn::module::Param<Tensor<1>>,
    constant694: burn::module::Param<Tensor<4>>,
    linear178: Linear,
    constant2042: burn::module::Param<Tensor<1>>,
    linear179: Linear,
    layernormalization98: LayerNorm,
    conv1d58: Conv1d,
    conv1d59: Conv1d,
    conv1d60: Conv1d,
    layernormalization99: LayerNorm,
    linear180: Linear,
    linear181: Linear,
    constant2044: burn::module::Param<Tensor<1>>,
    layernormalization100: LayerNorm,
    layernormalization101: LayerNorm,
    linear182: Linear,
    linear183: Linear,
    constant2045: burn::module::Param<Tensor<1>>,
    layernormalization102: LayerNorm,
    linear184: Linear,
    linear185: Linear,
    linear186: Linear,
    constant728: burn::module::Param<Tensor<1>>,
    constant729: burn::module::Param<Tensor<4>>,
    linear187: Linear,
    constant2059: burn::module::Param<Tensor<1>>,
    linear188: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule17 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization97 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear175 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear176 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear177 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant693: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant694: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear178 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2042: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear179 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization98 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d58 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d59 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d60 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization99 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear180 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear181 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2044: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization100 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization101 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear182 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear183 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2045: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization102 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear184 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear185 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear186 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant728: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant729: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear187 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2059: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear188 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization97,
            linear175,
            linear176,
            linear177,
            constant693,
            constant694,
            linear178,
            constant2042,
            linear179,
            layernormalization98,
            conv1d58,
            conv1d59,
            conv1d60,
            layernormalization99,
            linear180,
            linear181,
            constant2044,
            layernormalization100,
            layernormalization101,
            linear182,
            linear183,
            constant2045,
            layernormalization102,
            linear184,
            linear185,
            linear186,
            constant728,
            constant729,
            linear187,
            constant2059,
            linear188,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add115_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization97_out1 = {
            let dtype = add115_out1.clone().dtype();
            self.layernormalization97
                .forward(add115_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear175_out1 = self.linear175.forward(layernormalization97_out1.clone());
        let linear176_out1 = self.linear176.forward(layernormalization97_out1.clone());
        let linear177_out1 = self.linear177.forward(layernormalization97_out1);
        let constant693_out1 = self.constant693.val();
        let add116_out1 = linear175_out1
            .clone()
            .add((constant693_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape79_out1 = linear175_out1.reshape([0, -1, 8, 160]);
        let transpose79_out1 = reshape79_out1.permute([0, 2, 1, 3]);
        let constant694_out1 = self.constant694.val();
        let add117_out1 = transpose79_out1.clone().add(constant694_out1);
        let linear178_out1 = self.linear178.forward(reshape2_out1.clone());
        let reshape80_out1 = linear178_out1.reshape([0, -1, 8, 160]);
        let transpose80_out1 = reshape80_out1.permute([0, 2, 3, 1]);
        let matmul199_out1 = add117_out1.matmul(transpose80_out1);
        let pad20_out1 = matmul199_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape21_out1: [i64; 4] = {
            let axes = &transpose79_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather21_out1 = shape21_out1[2] as i64;
        let unsqueeze24_out1 = [gather21_out1 as i64];
        let constant2034_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat40_out1: [i64; 4usize] = [
            &constant2034_out1[..],
            &unsqueeze24_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape81_out1 = pad20_out1.reshape(concat40_out1);
        let slice39_out1 = reshape81_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2038_out1: [i64; 2] = [0i64, 0i64];
        let constant2039_out1: [i64; 1] = [-1i64];
        let concat41_out1: [i64; 4usize] = [
            &constant2038_out1[..],
            &unsqueeze24_out1[..],
            &constant2039_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape82_out1 = slice39_out1.reshape(concat41_out1);
        let slice40_out1 = reshape82_out1.slice(s![.., .., .., 0..unsqueeze24_out1[0]]);
        let constant2042_out1 = self.constant2042.val();
        let mul136_out1 = slice40_out1
            .mul((constant2042_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention20_out1,) = {
            let q = add116_out1;
            let k = linear176_out1;
            let v = linear177_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul136_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention20_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention20_out1 = {
                let dims = attention20_out1.dims();
                attention20_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention20_out1 = attention20_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention20_out1,)
        };
        let linear179_out1 = self.linear179.forward(attention20_out1);
        let add118_out1 = add115_out1.add(linear179_out1);
        let layernormalization98_out1 = {
            let dtype = add118_out1.clone().dtype();
            self.layernormalization98
                .forward(add118_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose81_out1 = layernormalization98_out1.permute([0, 2, 1]);
        let conv1d58_out1 = self.conv1d58.forward(transpose81_out1);
        let split_tensors = conv1d58_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split20_out1, split20_out2] = split_tensors.try_into().unwrap();
        let sigmoid78_out1 = burn::tensor::activation::sigmoid(split20_out2);
        let mul137_out1 = split20_out1.mul(sigmoid78_out1);
        let conv1d59_out1 = self.conv1d59.forward(mul137_out1);
        let sigmoid79_out1 = burn::tensor::activation::sigmoid(conv1d59_out1.clone());
        let mul138_out1 = conv1d59_out1.mul(sigmoid79_out1);
        let conv1d60_out1 = self.conv1d60.forward(mul138_out1);
        let transpose82_out1 = conv1d60_out1.permute([0, 2, 1]);
        let add119_out1 = add118_out1.add(transpose82_out1);
        let layernormalization99_out1 = {
            let dtype = add119_out1.clone().dtype();
            self.layernormalization99
                .forward(add119_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear180_out1 = self.linear180.forward(layernormalization99_out1);
        let sigmoid80_out1 = burn::tensor::activation::sigmoid(linear180_out1.clone());
        let mul139_out1 = linear180_out1.mul(sigmoid80_out1);
        let linear181_out1 = self.linear181.forward(mul139_out1);
        let constant2044_out1 = self.constant2044.val();
        let mul140_out1 = linear181_out1
            .mul((constant2044_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add120_out1 = add119_out1.add(mul140_out1);
        let layernormalization100_out1 = {
            let dtype = add120_out1.dtype();
            self.layernormalization100
                .forward(add120_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization101_out1 = {
            let dtype = layernormalization100_out1.clone().dtype();
            self.layernormalization101
                .forward(
                    layernormalization100_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear182_out1 = self.linear182.forward(layernormalization101_out1);
        let sigmoid81_out1 = burn::tensor::activation::sigmoid(linear182_out1.clone());
        let mul141_out1 = linear182_out1.mul(sigmoid81_out1);
        let linear183_out1 = self.linear183.forward(mul141_out1);
        let constant2045_out1 = self.constant2045.val();
        let mul142_out1 = linear183_out1
            .mul((constant2045_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add121_out1 = layernormalization100_out1.add(mul142_out1);
        let layernormalization102_out1 = {
            let dtype = add121_out1.clone().dtype();
            self.layernormalization102
                .forward(add121_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear184_out1 = self.linear184.forward(layernormalization102_out1.clone());
        let linear185_out1 = self.linear185.forward(layernormalization102_out1.clone());
        let linear186_out1 = self.linear186.forward(layernormalization102_out1);
        let constant728_out1 = self.constant728.val();
        let add122_out1 = linear184_out1
            .clone()
            .add((constant728_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape83_out1 = linear184_out1.reshape([0, -1, 8, 160]);
        let transpose83_out1 = reshape83_out1.permute([0, 2, 1, 3]);
        let constant729_out1 = self.constant729.val();
        let add123_out1 = transpose83_out1.clone().add(constant729_out1);
        let linear187_out1 = self.linear187.forward(reshape2_out1);
        let reshape84_out1 = linear187_out1.reshape([0, -1, 8, 160]);
        let transpose84_out1 = reshape84_out1.permute([0, 2, 3, 1]);
        let matmul209_out1 = add123_out1.matmul(transpose84_out1);
        let pad21_out1 = matmul209_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape22_out1: [i64; 4] = {
            let axes = &transpose83_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather22_out1 = shape22_out1[2] as i64;
        let unsqueeze25_out1 = [gather22_out1 as i64];
        let constant2051_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat42_out1: [i64; 4usize] = [
            &constant2051_out1[..],
            &unsqueeze25_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape85_out1 = pad21_out1.reshape(concat42_out1);
        let slice41_out1 = reshape85_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2055_out1: [i64; 2] = [0i64, 0i64];
        let constant2056_out1: [i64; 1] = [-1i64];
        let concat43_out1: [i64; 4usize] = [
            &constant2055_out1[..],
            &unsqueeze25_out1[..],
            &constant2056_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape86_out1 = slice41_out1.reshape(concat43_out1);
        let slice42_out1 = reshape86_out1.slice(s![.., .., .., 0..unsqueeze25_out1[0]]);
        let constant2059_out1 = self.constant2059.val();
        let mul143_out1 = slice42_out1
            .mul((constant2059_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention21_out1,) = {
            let q = add122_out1;
            let k = linear185_out1;
            let v = linear186_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul143_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention21_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention21_out1 = {
                let dims = attention21_out1.dims();
                attention21_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention21_out1 = attention21_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention21_out1,)
        };
        let linear188_out1 = self.linear188.forward(attention21_out1);
        let add124_out1 = add121_out1.add(linear188_out1);
        add124_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule18 {
    layernormalization103: LayerNorm,
    conv1d61: Conv1d,
    conv1d62: Conv1d,
    conv1d63: Conv1d,
    layernormalization104: LayerNorm,
    linear189: Linear,
    linear190: Linear,
    constant2061: burn::module::Param<Tensor<1>>,
    layernormalization105: LayerNorm,
    layernormalization106: LayerNorm,
    linear191: Linear,
    linear192: Linear,
    constant2062: burn::module::Param<Tensor<1>>,
    layernormalization107: LayerNorm,
    linear193: Linear,
    linear194: Linear,
    linear195: Linear,
    constant763: burn::module::Param<Tensor<1>>,
    constant764: burn::module::Param<Tensor<4>>,
    linear196: Linear,
    constant2076: burn::module::Param<Tensor<1>>,
    linear197: Linear,
    layernormalization108: LayerNorm,
    conv1d64: Conv1d,
    conv1d65: Conv1d,
    conv1d66: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule18 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization103 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d61 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d62 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d63 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization104 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear189 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear190 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2061: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization105 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization106 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear191 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear192 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2062: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization107 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear193 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear194 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear195 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant763: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant764: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear196 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2076: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear197 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization108 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d64 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d65 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d66 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization103,
            conv1d61,
            conv1d62,
            conv1d63,
            layernormalization104,
            linear189,
            linear190,
            constant2061,
            layernormalization105,
            layernormalization106,
            linear191,
            linear192,
            constant2062,
            layernormalization107,
            linear193,
            linear194,
            linear195,
            constant763,
            constant764,
            linear196,
            constant2076,
            linear197,
            layernormalization108,
            conv1d64,
            conv1d65,
            conv1d66,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add124_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization103_out1 = {
            let dtype = add124_out1.clone().dtype();
            self.layernormalization103
                .forward(add124_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose85_out1 = layernormalization103_out1.permute([0, 2, 1]);
        let conv1d61_out1 = self.conv1d61.forward(transpose85_out1);
        let split_tensors = conv1d61_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split21_out1, split21_out2] = split_tensors.try_into().unwrap();
        let sigmoid82_out1 = burn::tensor::activation::sigmoid(split21_out2);
        let mul144_out1 = split21_out1.mul(sigmoid82_out1);
        let conv1d62_out1 = self.conv1d62.forward(mul144_out1);
        let sigmoid83_out1 = burn::tensor::activation::sigmoid(conv1d62_out1.clone());
        let mul145_out1 = conv1d62_out1.mul(sigmoid83_out1);
        let conv1d63_out1 = self.conv1d63.forward(mul145_out1);
        let transpose86_out1 = conv1d63_out1.permute([0, 2, 1]);
        let add125_out1 = add124_out1.add(transpose86_out1);
        let layernormalization104_out1 = {
            let dtype = add125_out1.clone().dtype();
            self.layernormalization104
                .forward(add125_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear189_out1 = self.linear189.forward(layernormalization104_out1);
        let sigmoid84_out1 = burn::tensor::activation::sigmoid(linear189_out1.clone());
        let mul146_out1 = linear189_out1.mul(sigmoid84_out1);
        let linear190_out1 = self.linear190.forward(mul146_out1);
        let constant2061_out1 = self.constant2061.val();
        let mul147_out1 = linear190_out1
            .mul((constant2061_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add126_out1 = add125_out1.add(mul147_out1);
        let layernormalization105_out1 = {
            let dtype = add126_out1.dtype();
            self.layernormalization105
                .forward(add126_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization106_out1 = {
            let dtype = layernormalization105_out1.clone().dtype();
            self.layernormalization106
                .forward(
                    layernormalization105_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear191_out1 = self.linear191.forward(layernormalization106_out1);
        let sigmoid85_out1 = burn::tensor::activation::sigmoid(linear191_out1.clone());
        let mul148_out1 = linear191_out1.mul(sigmoid85_out1);
        let linear192_out1 = self.linear192.forward(mul148_out1);
        let constant2062_out1 = self.constant2062.val();
        let mul149_out1 = linear192_out1
            .mul((constant2062_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add127_out1 = layernormalization105_out1.add(mul149_out1);
        let layernormalization107_out1 = {
            let dtype = add127_out1.clone().dtype();
            self.layernormalization107
                .forward(add127_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear193_out1 = self.linear193.forward(layernormalization107_out1.clone());
        let linear194_out1 = self.linear194.forward(layernormalization107_out1.clone());
        let linear195_out1 = self.linear195.forward(layernormalization107_out1);
        let constant763_out1 = self.constant763.val();
        let add128_out1 = linear193_out1
            .clone()
            .add((constant763_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape87_out1 = linear193_out1.reshape([0, -1, 8, 160]);
        let transpose87_out1 = reshape87_out1.permute([0, 2, 1, 3]);
        let constant764_out1 = self.constant764.val();
        let add129_out1 = transpose87_out1.clone().add(constant764_out1);
        let linear196_out1 = self.linear196.forward(reshape2_out1);
        let reshape88_out1 = linear196_out1.reshape([0, -1, 8, 160]);
        let transpose88_out1 = reshape88_out1.permute([0, 2, 3, 1]);
        let matmul219_out1 = add129_out1.matmul(transpose88_out1);
        let pad22_out1 = matmul219_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape23_out1: [i64; 4] = {
            let axes = &transpose87_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather23_out1 = shape23_out1[2] as i64;
        let unsqueeze26_out1 = [gather23_out1 as i64];
        let constant2068_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat44_out1: [i64; 4usize] = [
            &constant2068_out1[..],
            &unsqueeze26_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape89_out1 = pad22_out1.reshape(concat44_out1);
        let slice43_out1 = reshape89_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2072_out1: [i64; 2] = [0i64, 0i64];
        let constant2073_out1: [i64; 1] = [-1i64];
        let concat45_out1: [i64; 4usize] = [
            &constant2072_out1[..],
            &unsqueeze26_out1[..],
            &constant2073_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape90_out1 = slice43_out1.reshape(concat45_out1);
        let slice44_out1 = reshape90_out1.slice(s![.., .., .., 0..unsqueeze26_out1[0]]);
        let constant2076_out1 = self.constant2076.val();
        let mul150_out1 = slice44_out1
            .mul((constant2076_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention22_out1,) = {
            let q = add128_out1;
            let k = linear194_out1;
            let v = linear195_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul150_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention22_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention22_out1 = {
                let dims = attention22_out1.dims();
                attention22_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention22_out1 = attention22_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention22_out1,)
        };
        let linear197_out1 = self.linear197.forward(attention22_out1);
        let add130_out1 = add127_out1.add(linear197_out1);
        let layernormalization108_out1 = {
            let dtype = add130_out1.clone().dtype();
            self.layernormalization108
                .forward(add130_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose89_out1 = layernormalization108_out1.permute([0, 2, 1]);
        let conv1d64_out1 = self.conv1d64.forward(transpose89_out1);
        let split_tensors = conv1d64_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split22_out1, split22_out2] = split_tensors.try_into().unwrap();
        let sigmoid86_out1 = burn::tensor::activation::sigmoid(split22_out2);
        let mul151_out1 = split22_out1.mul(sigmoid86_out1);
        let conv1d65_out1 = self.conv1d65.forward(mul151_out1);
        let sigmoid87_out1 = burn::tensor::activation::sigmoid(conv1d65_out1.clone());
        let mul152_out1 = conv1d65_out1.mul(sigmoid87_out1);
        let conv1d66_out1 = self.conv1d66.forward(mul152_out1);
        let transpose90_out1 = conv1d66_out1.permute([0, 2, 1]);
        let add131_out1 = add130_out1.add(transpose90_out1);
        add131_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule19 {
    layernormalization109: LayerNorm,
    linear198: Linear,
    linear199: Linear,
    constant2078: burn::module::Param<Tensor<1>>,
    layernormalization110: LayerNorm,
    layernormalization111: LayerNorm,
    linear200: Linear,
    linear201: Linear,
    constant2079: burn::module::Param<Tensor<1>>,
    layernormalization112: LayerNorm,
    linear202: Linear,
    linear203: Linear,
    linear204: Linear,
    constant798: burn::module::Param<Tensor<1>>,
    constant799: burn::module::Param<Tensor<4>>,
    linear205: Linear,
    constant2093: burn::module::Param<Tensor<1>>,
    linear206: Linear,
    layernormalization113: LayerNorm,
    conv1d67: Conv1d,
    conv1d68: Conv1d,
    conv1d69: Conv1d,
    layernormalization114: LayerNorm,
    linear207: Linear,
    linear208: Linear,
    constant2095: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule19 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization109 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear198 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear199 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2078: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization110 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization111 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear200 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear201 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2079: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization112 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear202 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear203 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear204 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant798: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant799: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear205 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2093: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear206 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization113 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d67 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d68 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d69 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization114 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear207 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear208 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2095: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization109,
            linear198,
            linear199,
            constant2078,
            layernormalization110,
            layernormalization111,
            linear200,
            linear201,
            constant2079,
            layernormalization112,
            linear202,
            linear203,
            linear204,
            constant798,
            constant799,
            linear205,
            constant2093,
            linear206,
            layernormalization113,
            conv1d67,
            conv1d68,
            conv1d69,
            layernormalization114,
            linear207,
            linear208,
            constant2095,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add131_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization109_out1 = {
            let dtype = add131_out1.clone().dtype();
            self.layernormalization109
                .forward(add131_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear198_out1 = self.linear198.forward(layernormalization109_out1);
        let sigmoid88_out1 = burn::tensor::activation::sigmoid(linear198_out1.clone());
        let mul153_out1 = linear198_out1.mul(sigmoid88_out1);
        let linear199_out1 = self.linear199.forward(mul153_out1);
        let constant2078_out1 = self.constant2078.val();
        let mul154_out1 = linear199_out1
            .mul((constant2078_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add132_out1 = add131_out1.add(mul154_out1);
        let layernormalization110_out1 = {
            let dtype = add132_out1.dtype();
            self.layernormalization110
                .forward(add132_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization111_out1 = {
            let dtype = layernormalization110_out1.clone().dtype();
            self.layernormalization111
                .forward(
                    layernormalization110_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear200_out1 = self.linear200.forward(layernormalization111_out1);
        let sigmoid89_out1 = burn::tensor::activation::sigmoid(linear200_out1.clone());
        let mul155_out1 = linear200_out1.mul(sigmoid89_out1);
        let linear201_out1 = self.linear201.forward(mul155_out1);
        let constant2079_out1 = self.constant2079.val();
        let mul156_out1 = linear201_out1
            .mul((constant2079_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add133_out1 = layernormalization110_out1.add(mul156_out1);
        let layernormalization112_out1 = {
            let dtype = add133_out1.clone().dtype();
            self.layernormalization112
                .forward(add133_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear202_out1 = self.linear202.forward(layernormalization112_out1.clone());
        let linear203_out1 = self.linear203.forward(layernormalization112_out1.clone());
        let linear204_out1 = self.linear204.forward(layernormalization112_out1);
        let constant798_out1 = self.constant798.val();
        let add134_out1 = linear202_out1
            .clone()
            .add((constant798_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape91_out1 = linear202_out1.reshape([0, -1, 8, 160]);
        let transpose91_out1 = reshape91_out1.permute([0, 2, 1, 3]);
        let constant799_out1 = self.constant799.val();
        let add135_out1 = transpose91_out1.clone().add(constant799_out1);
        let linear205_out1 = self.linear205.forward(reshape2_out1);
        let reshape92_out1 = linear205_out1.reshape([0, -1, 8, 160]);
        let transpose92_out1 = reshape92_out1.permute([0, 2, 3, 1]);
        let matmul229_out1 = add135_out1.matmul(transpose92_out1);
        let pad23_out1 = matmul229_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape24_out1: [i64; 4] = {
            let axes = &transpose91_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather24_out1 = shape24_out1[2] as i64;
        let unsqueeze27_out1 = [gather24_out1 as i64];
        let constant2085_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat46_out1: [i64; 4usize] = [
            &constant2085_out1[..],
            &unsqueeze27_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape93_out1 = pad23_out1.reshape(concat46_out1);
        let slice45_out1 = reshape93_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2089_out1: [i64; 2] = [0i64, 0i64];
        let constant2090_out1: [i64; 1] = [-1i64];
        let concat47_out1: [i64; 4usize] = [
            &constant2089_out1[..],
            &unsqueeze27_out1[..],
            &constant2090_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape94_out1 = slice45_out1.reshape(concat47_out1);
        let slice46_out1 = reshape94_out1.slice(s![.., .., .., 0..unsqueeze27_out1[0]]);
        let constant2093_out1 = self.constant2093.val();
        let mul157_out1 = slice46_out1
            .mul((constant2093_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention23_out1,) = {
            let q = add134_out1;
            let k = linear203_out1;
            let v = linear204_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul157_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention23_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention23_out1 = {
                let dims = attention23_out1.dims();
                attention23_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention23_out1 = attention23_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention23_out1,)
        };
        let linear206_out1 = self.linear206.forward(attention23_out1);
        let add136_out1 = add133_out1.add(linear206_out1);
        let layernormalization113_out1 = {
            let dtype = add136_out1.clone().dtype();
            self.layernormalization113
                .forward(add136_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose93_out1 = layernormalization113_out1.permute([0, 2, 1]);
        let conv1d67_out1 = self.conv1d67.forward(transpose93_out1);
        let split_tensors = conv1d67_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split23_out1, split23_out2] = split_tensors.try_into().unwrap();
        let sigmoid90_out1 = burn::tensor::activation::sigmoid(split23_out2);
        let mul158_out1 = split23_out1.mul(sigmoid90_out1);
        let conv1d68_out1 = self.conv1d68.forward(mul158_out1);
        let sigmoid91_out1 = burn::tensor::activation::sigmoid(conv1d68_out1.clone());
        let mul159_out1 = conv1d68_out1.mul(sigmoid91_out1);
        let conv1d69_out1 = self.conv1d69.forward(mul159_out1);
        let transpose94_out1 = conv1d69_out1.permute([0, 2, 1]);
        let add137_out1 = add136_out1.add(transpose94_out1);
        let layernormalization114_out1 = {
            let dtype = add137_out1.clone().dtype();
            self.layernormalization114
                .forward(add137_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear207_out1 = self.linear207.forward(layernormalization114_out1);
        let sigmoid92_out1 = burn::tensor::activation::sigmoid(linear207_out1.clone());
        let mul160_out1 = linear207_out1.mul(sigmoid92_out1);
        let linear208_out1 = self.linear208.forward(mul160_out1);
        let constant2095_out1 = self.constant2095.val();
        let mul161_out1 = linear208_out1
            .mul((constant2095_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add138_out1 = add137_out1.add(mul161_out1);
        add138_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule20 {
    layernormalization115: LayerNorm,
    layernormalization116: LayerNorm,
    linear209: Linear,
    linear210: Linear,
    constant2096: burn::module::Param<Tensor<1>>,
    layernormalization117: LayerNorm,
    linear211: Linear,
    linear212: Linear,
    linear213: Linear,
    constant833: burn::module::Param<Tensor<1>>,
    constant834: burn::module::Param<Tensor<4>>,
    linear214: Linear,
    constant2110: burn::module::Param<Tensor<1>>,
    linear215: Linear,
    layernormalization118: LayerNorm,
    conv1d70: Conv1d,
    conv1d71: Conv1d,
    conv1d72: Conv1d,
    layernormalization119: LayerNorm,
    linear216: Linear,
    linear217: Linear,
    constant2112: burn::module::Param<Tensor<1>>,
    layernormalization120: LayerNorm,
    layernormalization121: LayerNorm,
    linear218: Linear,
    linear219: Linear,
    constant2113: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule20 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization115 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization116 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear209 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear210 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2096: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization117 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear211 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear212 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear213 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant833: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant834: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear214 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2110: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear215 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization118 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d70 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d71 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d72 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization119 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear216 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear217 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2112: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization120 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization121 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear218 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear219 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2113: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization115,
            layernormalization116,
            linear209,
            linear210,
            constant2096,
            layernormalization117,
            linear211,
            linear212,
            linear213,
            constant833,
            constant834,
            linear214,
            constant2110,
            linear215,
            layernormalization118,
            conv1d70,
            conv1d71,
            conv1d72,
            layernormalization119,
            linear216,
            linear217,
            constant2112,
            layernormalization120,
            layernormalization121,
            linear218,
            linear219,
            constant2113,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add138_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization115_out1 = {
            let dtype = add138_out1.dtype();
            self.layernormalization115
                .forward(add138_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization116_out1 = {
            let dtype = layernormalization115_out1.clone().dtype();
            self.layernormalization116
                .forward(
                    layernormalization115_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear209_out1 = self.linear209.forward(layernormalization116_out1);
        let sigmoid93_out1 = burn::tensor::activation::sigmoid(linear209_out1.clone());
        let mul162_out1 = linear209_out1.mul(sigmoid93_out1);
        let linear210_out1 = self.linear210.forward(mul162_out1);
        let constant2096_out1 = self.constant2096.val();
        let mul163_out1 = linear210_out1
            .mul((constant2096_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add139_out1 = layernormalization115_out1.add(mul163_out1);
        let layernormalization117_out1 = {
            let dtype = add139_out1.clone().dtype();
            self.layernormalization117
                .forward(add139_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear211_out1 = self.linear211.forward(layernormalization117_out1.clone());
        let linear212_out1 = self.linear212.forward(layernormalization117_out1.clone());
        let linear213_out1 = self.linear213.forward(layernormalization117_out1);
        let constant833_out1 = self.constant833.val();
        let add140_out1 = linear211_out1
            .clone()
            .add((constant833_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape95_out1 = linear211_out1.reshape([0, -1, 8, 160]);
        let transpose95_out1 = reshape95_out1.permute([0, 2, 1, 3]);
        let constant834_out1 = self.constant834.val();
        let add141_out1 = transpose95_out1.clone().add(constant834_out1);
        let linear214_out1 = self.linear214.forward(reshape2_out1);
        let reshape96_out1 = linear214_out1.reshape([0, -1, 8, 160]);
        let transpose96_out1 = reshape96_out1.permute([0, 2, 3, 1]);
        let matmul239_out1 = add141_out1.matmul(transpose96_out1);
        let pad24_out1 = matmul239_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape25_out1: [i64; 4] = {
            let axes = &transpose95_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather25_out1 = shape25_out1[2] as i64;
        let unsqueeze28_out1 = [gather25_out1 as i64];
        let constant2102_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat48_out1: [i64; 4usize] = [
            &constant2102_out1[..],
            &unsqueeze28_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape97_out1 = pad24_out1.reshape(concat48_out1);
        let slice47_out1 = reshape97_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2106_out1: [i64; 2] = [0i64, 0i64];
        let constant2107_out1: [i64; 1] = [-1i64];
        let concat49_out1: [i64; 4usize] = [
            &constant2106_out1[..],
            &unsqueeze28_out1[..],
            &constant2107_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape98_out1 = slice47_out1.reshape(concat49_out1);
        let slice48_out1 = reshape98_out1.slice(s![.., .., .., 0..unsqueeze28_out1[0]]);
        let constant2110_out1 = self.constant2110.val();
        let mul164_out1 = slice48_out1
            .mul((constant2110_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention24_out1,) = {
            let q = add140_out1;
            let k = linear212_out1;
            let v = linear213_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul164_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention24_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention24_out1 = {
                let dims = attention24_out1.dims();
                attention24_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention24_out1 = attention24_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention24_out1,)
        };
        let linear215_out1 = self.linear215.forward(attention24_out1);
        let add142_out1 = add139_out1.add(linear215_out1);
        let layernormalization118_out1 = {
            let dtype = add142_out1.clone().dtype();
            self.layernormalization118
                .forward(add142_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose97_out1 = layernormalization118_out1.permute([0, 2, 1]);
        let conv1d70_out1 = self.conv1d70.forward(transpose97_out1);
        let split_tensors = conv1d70_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split24_out1, split24_out2] = split_tensors.try_into().unwrap();
        let sigmoid94_out1 = burn::tensor::activation::sigmoid(split24_out2);
        let mul165_out1 = split24_out1.mul(sigmoid94_out1);
        let conv1d71_out1 = self.conv1d71.forward(mul165_out1);
        let sigmoid95_out1 = burn::tensor::activation::sigmoid(conv1d71_out1.clone());
        let mul166_out1 = conv1d71_out1.mul(sigmoid95_out1);
        let conv1d72_out1 = self.conv1d72.forward(mul166_out1);
        let transpose98_out1 = conv1d72_out1.permute([0, 2, 1]);
        let add143_out1 = add142_out1.add(transpose98_out1);
        let layernormalization119_out1 = {
            let dtype = add143_out1.clone().dtype();
            self.layernormalization119
                .forward(add143_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear216_out1 = self.linear216.forward(layernormalization119_out1);
        let sigmoid96_out1 = burn::tensor::activation::sigmoid(linear216_out1.clone());
        let mul167_out1 = linear216_out1.mul(sigmoid96_out1);
        let linear217_out1 = self.linear217.forward(mul167_out1);
        let constant2112_out1 = self.constant2112.val();
        let mul168_out1 = linear217_out1
            .mul((constant2112_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add144_out1 = add143_out1.add(mul168_out1);
        let layernormalization120_out1 = {
            let dtype = add144_out1.dtype();
            self.layernormalization120
                .forward(add144_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization121_out1 = {
            let dtype = layernormalization120_out1.clone().dtype();
            self.layernormalization121
                .forward(
                    layernormalization120_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear218_out1 = self.linear218.forward(layernormalization121_out1);
        let sigmoid97_out1 = burn::tensor::activation::sigmoid(linear218_out1.clone());
        let mul169_out1 = linear218_out1.mul(sigmoid97_out1);
        let linear219_out1 = self.linear219.forward(mul169_out1);
        let constant2113_out1 = self.constant2113.val();
        let mul170_out1 = linear219_out1
            .mul((constant2113_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add145_out1 = layernormalization120_out1.add(mul170_out1);
        add145_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule21 {
    layernormalization122: LayerNorm,
    linear220: Linear,
    linear221: Linear,
    linear222: Linear,
    constant868: burn::module::Param<Tensor<1>>,
    constant869: burn::module::Param<Tensor<4>>,
    linear223: Linear,
    constant2127: burn::module::Param<Tensor<1>>,
    linear224: Linear,
    layernormalization123: LayerNorm,
    conv1d73: Conv1d,
    conv1d74: Conv1d,
    conv1d75: Conv1d,
    layernormalization124: LayerNorm,
    linear225: Linear,
    linear226: Linear,
    constant2129: burn::module::Param<Tensor<1>>,
    layernormalization125: LayerNorm,
    layernormalization126: LayerNorm,
    linear227: Linear,
    linear228: Linear,
    constant2130: burn::module::Param<Tensor<1>>,
    layernormalization127: LayerNorm,
    linear229: Linear,
    linear230: Linear,
    linear231: Linear,
    constant903: burn::module::Param<Tensor<1>>,
    constant904: burn::module::Param<Tensor<4>>,
    linear232: Linear,
    constant2144: burn::module::Param<Tensor<1>>,
    linear233: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule21 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization122 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear220 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear221 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear222 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant868: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant869: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear223 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2127: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear224 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization123 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d73 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d74 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d75 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization124 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear225 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear226 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2129: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization125 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization126 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear227 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear228 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2130: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization127 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear229 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear230 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear231 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant903: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant904: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear232 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2144: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear233 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization122,
            linear220,
            linear221,
            linear222,
            constant868,
            constant869,
            linear223,
            constant2127,
            linear224,
            layernormalization123,
            conv1d73,
            conv1d74,
            conv1d75,
            layernormalization124,
            linear225,
            linear226,
            constant2129,
            layernormalization125,
            layernormalization126,
            linear227,
            linear228,
            constant2130,
            layernormalization127,
            linear229,
            linear230,
            linear231,
            constant903,
            constant904,
            linear232,
            constant2144,
            linear233,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add145_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization122_out1 = {
            let dtype = add145_out1.clone().dtype();
            self.layernormalization122
                .forward(add145_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear220_out1 = self.linear220.forward(layernormalization122_out1.clone());
        let linear221_out1 = self.linear221.forward(layernormalization122_out1.clone());
        let linear222_out1 = self.linear222.forward(layernormalization122_out1);
        let constant868_out1 = self.constant868.val();
        let add146_out1 = linear220_out1
            .clone()
            .add((constant868_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape99_out1 = linear220_out1.reshape([0, -1, 8, 160]);
        let transpose99_out1 = reshape99_out1.permute([0, 2, 1, 3]);
        let constant869_out1 = self.constant869.val();
        let add147_out1 = transpose99_out1.clone().add(constant869_out1);
        let linear223_out1 = self.linear223.forward(reshape2_out1.clone());
        let reshape100_out1 = linear223_out1.reshape([0, -1, 8, 160]);
        let transpose100_out1 = reshape100_out1.permute([0, 2, 3, 1]);
        let matmul249_out1 = add147_out1.matmul(transpose100_out1);
        let pad25_out1 = matmul249_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape26_out1: [i64; 4] = {
            let axes = &transpose99_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather26_out1 = shape26_out1[2] as i64;
        let unsqueeze29_out1 = [gather26_out1 as i64];
        let constant2119_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat50_out1: [i64; 4usize] = [
            &constant2119_out1[..],
            &unsqueeze29_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape101_out1 = pad25_out1.reshape(concat50_out1);
        let slice49_out1 = reshape101_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2123_out1: [i64; 2] = [0i64, 0i64];
        let constant2124_out1: [i64; 1] = [-1i64];
        let concat51_out1: [i64; 4usize] = [
            &constant2123_out1[..],
            &unsqueeze29_out1[..],
            &constant2124_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape102_out1 = slice49_out1.reshape(concat51_out1);
        let slice50_out1 = reshape102_out1.slice(s![.., .., .., 0..unsqueeze29_out1[0]]);
        let constant2127_out1 = self.constant2127.val();
        let mul171_out1 = slice50_out1
            .mul((constant2127_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention25_out1,) = {
            let q = add146_out1;
            let k = linear221_out1;
            let v = linear222_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul171_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention25_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention25_out1 = {
                let dims = attention25_out1.dims();
                attention25_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention25_out1 = attention25_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention25_out1,)
        };
        let linear224_out1 = self.linear224.forward(attention25_out1);
        let add148_out1 = add145_out1.add(linear224_out1);
        let layernormalization123_out1 = {
            let dtype = add148_out1.clone().dtype();
            self.layernormalization123
                .forward(add148_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose101_out1 = layernormalization123_out1.permute([0, 2, 1]);
        let conv1d73_out1 = self.conv1d73.forward(transpose101_out1);
        let split_tensors = conv1d73_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split25_out1, split25_out2] = split_tensors.try_into().unwrap();
        let sigmoid98_out1 = burn::tensor::activation::sigmoid(split25_out2);
        let mul172_out1 = split25_out1.mul(sigmoid98_out1);
        let conv1d74_out1 = self.conv1d74.forward(mul172_out1);
        let sigmoid99_out1 = burn::tensor::activation::sigmoid(conv1d74_out1.clone());
        let mul173_out1 = conv1d74_out1.mul(sigmoid99_out1);
        let conv1d75_out1 = self.conv1d75.forward(mul173_out1);
        let transpose102_out1 = conv1d75_out1.permute([0, 2, 1]);
        let add149_out1 = add148_out1.add(transpose102_out1);
        let layernormalization124_out1 = {
            let dtype = add149_out1.clone().dtype();
            self.layernormalization124
                .forward(add149_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear225_out1 = self.linear225.forward(layernormalization124_out1);
        let sigmoid100_out1 = burn::tensor::activation::sigmoid(linear225_out1.clone());
        let mul174_out1 = linear225_out1.mul(sigmoid100_out1);
        let linear226_out1 = self.linear226.forward(mul174_out1);
        let constant2129_out1 = self.constant2129.val();
        let mul175_out1 = linear226_out1
            .mul((constant2129_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add150_out1 = add149_out1.add(mul175_out1);
        let layernormalization125_out1 = {
            let dtype = add150_out1.dtype();
            self.layernormalization125
                .forward(add150_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization126_out1 = {
            let dtype = layernormalization125_out1.clone().dtype();
            self.layernormalization126
                .forward(
                    layernormalization125_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear227_out1 = self.linear227.forward(layernormalization126_out1);
        let sigmoid101_out1 = burn::tensor::activation::sigmoid(linear227_out1.clone());
        let mul176_out1 = linear227_out1.mul(sigmoid101_out1);
        let linear228_out1 = self.linear228.forward(mul176_out1);
        let constant2130_out1 = self.constant2130.val();
        let mul177_out1 = linear228_out1
            .mul((constant2130_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add151_out1 = layernormalization125_out1.add(mul177_out1);
        let layernormalization127_out1 = {
            let dtype = add151_out1.clone().dtype();
            self.layernormalization127
                .forward(add151_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear229_out1 = self.linear229.forward(layernormalization127_out1.clone());
        let linear230_out1 = self.linear230.forward(layernormalization127_out1.clone());
        let linear231_out1 = self.linear231.forward(layernormalization127_out1);
        let constant903_out1 = self.constant903.val();
        let add152_out1 = linear229_out1
            .clone()
            .add((constant903_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape103_out1 = linear229_out1.reshape([0, -1, 8, 160]);
        let transpose103_out1 = reshape103_out1.permute([0, 2, 1, 3]);
        let constant904_out1 = self.constant904.val();
        let add153_out1 = transpose103_out1.clone().add(constant904_out1);
        let linear232_out1 = self.linear232.forward(reshape2_out1);
        let reshape104_out1 = linear232_out1.reshape([0, -1, 8, 160]);
        let transpose104_out1 = reshape104_out1.permute([0, 2, 3, 1]);
        let matmul259_out1 = add153_out1.matmul(transpose104_out1);
        let pad26_out1 = matmul259_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape27_out1: [i64; 4] = {
            let axes = &transpose103_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather27_out1 = shape27_out1[2] as i64;
        let unsqueeze30_out1 = [gather27_out1 as i64];
        let constant2136_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat52_out1: [i64; 4usize] = [
            &constant2136_out1[..],
            &unsqueeze30_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape105_out1 = pad26_out1.reshape(concat52_out1);
        let slice51_out1 = reshape105_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2140_out1: [i64; 2] = [0i64, 0i64];
        let constant2141_out1: [i64; 1] = [-1i64];
        let concat53_out1: [i64; 4usize] = [
            &constant2140_out1[..],
            &unsqueeze30_out1[..],
            &constant2141_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape106_out1 = slice51_out1.reshape(concat53_out1);
        let slice52_out1 = reshape106_out1.slice(s![.., .., .., 0..unsqueeze30_out1[0]]);
        let constant2144_out1 = self.constant2144.val();
        let mul178_out1 = slice52_out1
            .mul((constant2144_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention26_out1,) = {
            let q = add152_out1;
            let k = linear230_out1;
            let v = linear231_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul178_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention26_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention26_out1 = {
                let dims = attention26_out1.dims();
                attention26_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention26_out1 = attention26_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention26_out1,)
        };
        let linear233_out1 = self.linear233.forward(attention26_out1);
        let add154_out1 = add151_out1.add(linear233_out1);
        add154_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule22 {
    layernormalization128: LayerNorm,
    conv1d76: Conv1d,
    conv1d77: Conv1d,
    conv1d78: Conv1d,
    layernormalization129: LayerNorm,
    linear234: Linear,
    linear235: Linear,
    constant2146: burn::module::Param<Tensor<1>>,
    layernormalization130: LayerNorm,
    layernormalization131: LayerNorm,
    linear236: Linear,
    linear237: Linear,
    constant2147: burn::module::Param<Tensor<1>>,
    layernormalization132: LayerNorm,
    linear238: Linear,
    linear239: Linear,
    linear240: Linear,
    constant938: burn::module::Param<Tensor<1>>,
    constant939: burn::module::Param<Tensor<4>>,
    linear241: Linear,
    constant2161: burn::module::Param<Tensor<1>>,
    linear242: Linear,
    layernormalization133: LayerNorm,
    conv1d79: Conv1d,
    conv1d80: Conv1d,
    conv1d81: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule22 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization128 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d76 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d77 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d78 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization129 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear234 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear235 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2146: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization130 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization131 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear236 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear237 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2147: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization132 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear238 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear239 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear240 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant938: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant939: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear241 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2161: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear242 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization133 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d79 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d80 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d81 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization128,
            conv1d76,
            conv1d77,
            conv1d78,
            layernormalization129,
            linear234,
            linear235,
            constant2146,
            layernormalization130,
            layernormalization131,
            linear236,
            linear237,
            constant2147,
            layernormalization132,
            linear238,
            linear239,
            linear240,
            constant938,
            constant939,
            linear241,
            constant2161,
            linear242,
            layernormalization133,
            conv1d79,
            conv1d80,
            conv1d81,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add154_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization128_out1 = {
            let dtype = add154_out1.clone().dtype();
            self.layernormalization128
                .forward(add154_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose105_out1 = layernormalization128_out1.permute([0, 2, 1]);
        let conv1d76_out1 = self.conv1d76.forward(transpose105_out1);
        let split_tensors = conv1d76_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split26_out1, split26_out2] = split_tensors.try_into().unwrap();
        let sigmoid102_out1 = burn::tensor::activation::sigmoid(split26_out2);
        let mul179_out1 = split26_out1.mul(sigmoid102_out1);
        let conv1d77_out1 = self.conv1d77.forward(mul179_out1);
        let sigmoid103_out1 = burn::tensor::activation::sigmoid(conv1d77_out1.clone());
        let mul180_out1 = conv1d77_out1.mul(sigmoid103_out1);
        let conv1d78_out1 = self.conv1d78.forward(mul180_out1);
        let transpose106_out1 = conv1d78_out1.permute([0, 2, 1]);
        let add155_out1 = add154_out1.add(transpose106_out1);
        let layernormalization129_out1 = {
            let dtype = add155_out1.clone().dtype();
            self.layernormalization129
                .forward(add155_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear234_out1 = self.linear234.forward(layernormalization129_out1);
        let sigmoid104_out1 = burn::tensor::activation::sigmoid(linear234_out1.clone());
        let mul181_out1 = linear234_out1.mul(sigmoid104_out1);
        let linear235_out1 = self.linear235.forward(mul181_out1);
        let constant2146_out1 = self.constant2146.val();
        let mul182_out1 = linear235_out1
            .mul((constant2146_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add156_out1 = add155_out1.add(mul182_out1);
        let layernormalization130_out1 = {
            let dtype = add156_out1.dtype();
            self.layernormalization130
                .forward(add156_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization131_out1 = {
            let dtype = layernormalization130_out1.clone().dtype();
            self.layernormalization131
                .forward(
                    layernormalization130_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear236_out1 = self.linear236.forward(layernormalization131_out1);
        let sigmoid105_out1 = burn::tensor::activation::sigmoid(linear236_out1.clone());
        let mul183_out1 = linear236_out1.mul(sigmoid105_out1);
        let linear237_out1 = self.linear237.forward(mul183_out1);
        let constant2147_out1 = self.constant2147.val();
        let mul184_out1 = linear237_out1
            .mul((constant2147_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add157_out1 = layernormalization130_out1.add(mul184_out1);
        let layernormalization132_out1 = {
            let dtype = add157_out1.clone().dtype();
            self.layernormalization132
                .forward(add157_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear238_out1 = self.linear238.forward(layernormalization132_out1.clone());
        let linear239_out1 = self.linear239.forward(layernormalization132_out1.clone());
        let linear240_out1 = self.linear240.forward(layernormalization132_out1);
        let constant938_out1 = self.constant938.val();
        let add158_out1 = linear238_out1
            .clone()
            .add((constant938_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape107_out1 = linear238_out1.reshape([0, -1, 8, 160]);
        let transpose107_out1 = reshape107_out1.permute([0, 2, 1, 3]);
        let constant939_out1 = self.constant939.val();
        let add159_out1 = transpose107_out1.clone().add(constant939_out1);
        let linear241_out1 = self.linear241.forward(reshape2_out1);
        let reshape108_out1 = linear241_out1.reshape([0, -1, 8, 160]);
        let transpose108_out1 = reshape108_out1.permute([0, 2, 3, 1]);
        let matmul269_out1 = add159_out1.matmul(transpose108_out1);
        let pad27_out1 = matmul269_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape28_out1: [i64; 4] = {
            let axes = &transpose107_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather28_out1 = shape28_out1[2] as i64;
        let unsqueeze31_out1 = [gather28_out1 as i64];
        let constant2153_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat54_out1: [i64; 4usize] = [
            &constant2153_out1[..],
            &unsqueeze31_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape109_out1 = pad27_out1.reshape(concat54_out1);
        let slice53_out1 = reshape109_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2157_out1: [i64; 2] = [0i64, 0i64];
        let constant2158_out1: [i64; 1] = [-1i64];
        let concat55_out1: [i64; 4usize] = [
            &constant2157_out1[..],
            &unsqueeze31_out1[..],
            &constant2158_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape110_out1 = slice53_out1.reshape(concat55_out1);
        let slice54_out1 = reshape110_out1.slice(s![.., .., .., 0..unsqueeze31_out1[0]]);
        let constant2161_out1 = self.constant2161.val();
        let mul185_out1 = slice54_out1
            .mul((constant2161_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention27_out1,) = {
            let q = add158_out1;
            let k = linear239_out1;
            let v = linear240_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul185_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention27_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention27_out1 = {
                let dims = attention27_out1.dims();
                attention27_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention27_out1 = attention27_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention27_out1,)
        };
        let linear242_out1 = self.linear242.forward(attention27_out1);
        let add160_out1 = add157_out1.add(linear242_out1);
        let layernormalization133_out1 = {
            let dtype = add160_out1.clone().dtype();
            self.layernormalization133
                .forward(add160_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose109_out1 = layernormalization133_out1.permute([0, 2, 1]);
        let conv1d79_out1 = self.conv1d79.forward(transpose109_out1);
        let split_tensors = conv1d79_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split27_out1, split27_out2] = split_tensors.try_into().unwrap();
        let sigmoid106_out1 = burn::tensor::activation::sigmoid(split27_out2);
        let mul186_out1 = split27_out1.mul(sigmoid106_out1);
        let conv1d80_out1 = self.conv1d80.forward(mul186_out1);
        let sigmoid107_out1 = burn::tensor::activation::sigmoid(conv1d80_out1.clone());
        let mul187_out1 = conv1d80_out1.mul(sigmoid107_out1);
        let conv1d81_out1 = self.conv1d81.forward(mul187_out1);
        let transpose110_out1 = conv1d81_out1.permute([0, 2, 1]);
        let add161_out1 = add160_out1.add(transpose110_out1);
        add161_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule23 {
    layernormalization134: LayerNorm,
    linear243: Linear,
    linear244: Linear,
    constant2163: burn::module::Param<Tensor<1>>,
    layernormalization135: LayerNorm,
    layernormalization136: LayerNorm,
    linear245: Linear,
    linear246: Linear,
    constant2164: burn::module::Param<Tensor<1>>,
    layernormalization137: LayerNorm,
    linear247: Linear,
    linear248: Linear,
    linear249: Linear,
    constant973: burn::module::Param<Tensor<1>>,
    constant974: burn::module::Param<Tensor<4>>,
    linear250: Linear,
    constant2178: burn::module::Param<Tensor<1>>,
    linear251: Linear,
    layernormalization138: LayerNorm,
    conv1d82: Conv1d,
    conv1d83: Conv1d,
    conv1d84: Conv1d,
    layernormalization139: LayerNorm,
    linear252: Linear,
    linear253: Linear,
    constant2180: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule23 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization134 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear243 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear244 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2163: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization135 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization136 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear245 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear246 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2164: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization137 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear247 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear248 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear249 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant973: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant974: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear250 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2178: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear251 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization138 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d82 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d83 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d84 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization139 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear252 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear253 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2180: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization134,
            linear243,
            linear244,
            constant2163,
            layernormalization135,
            layernormalization136,
            linear245,
            linear246,
            constant2164,
            layernormalization137,
            linear247,
            linear248,
            linear249,
            constant973,
            constant974,
            linear250,
            constant2178,
            linear251,
            layernormalization138,
            conv1d82,
            conv1d83,
            conv1d84,
            layernormalization139,
            linear252,
            linear253,
            constant2180,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add161_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization134_out1 = {
            let dtype = add161_out1.clone().dtype();
            self.layernormalization134
                .forward(add161_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear243_out1 = self.linear243.forward(layernormalization134_out1);
        let sigmoid108_out1 = burn::tensor::activation::sigmoid(linear243_out1.clone());
        let mul188_out1 = linear243_out1.mul(sigmoid108_out1);
        let linear244_out1 = self.linear244.forward(mul188_out1);
        let constant2163_out1 = self.constant2163.val();
        let mul189_out1 = linear244_out1
            .mul((constant2163_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add162_out1 = add161_out1.add(mul189_out1);
        let layernormalization135_out1 = {
            let dtype = add162_out1.dtype();
            self.layernormalization135
                .forward(add162_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization136_out1 = {
            let dtype = layernormalization135_out1.clone().dtype();
            self.layernormalization136
                .forward(
                    layernormalization135_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear245_out1 = self.linear245.forward(layernormalization136_out1);
        let sigmoid109_out1 = burn::tensor::activation::sigmoid(linear245_out1.clone());
        let mul190_out1 = linear245_out1.mul(sigmoid109_out1);
        let linear246_out1 = self.linear246.forward(mul190_out1);
        let constant2164_out1 = self.constant2164.val();
        let mul191_out1 = linear246_out1
            .mul((constant2164_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add163_out1 = layernormalization135_out1.add(mul191_out1);
        let layernormalization137_out1 = {
            let dtype = add163_out1.clone().dtype();
            self.layernormalization137
                .forward(add163_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear247_out1 = self.linear247.forward(layernormalization137_out1.clone());
        let linear248_out1 = self.linear248.forward(layernormalization137_out1.clone());
        let linear249_out1 = self.linear249.forward(layernormalization137_out1);
        let constant973_out1 = self.constant973.val();
        let add164_out1 = linear247_out1
            .clone()
            .add((constant973_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape111_out1 = linear247_out1.reshape([0, -1, 8, 160]);
        let transpose111_out1 = reshape111_out1.permute([0, 2, 1, 3]);
        let constant974_out1 = self.constant974.val();
        let add165_out1 = transpose111_out1.clone().add(constant974_out1);
        let linear250_out1 = self.linear250.forward(reshape2_out1);
        let reshape112_out1 = linear250_out1.reshape([0, -1, 8, 160]);
        let transpose112_out1 = reshape112_out1.permute([0, 2, 3, 1]);
        let matmul279_out1 = add165_out1.matmul(transpose112_out1);
        let pad28_out1 = matmul279_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape29_out1: [i64; 4] = {
            let axes = &transpose111_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather29_out1 = shape29_out1[2] as i64;
        let unsqueeze32_out1 = [gather29_out1 as i64];
        let constant2170_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat56_out1: [i64; 4usize] = [
            &constant2170_out1[..],
            &unsqueeze32_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape113_out1 = pad28_out1.reshape(concat56_out1);
        let slice55_out1 = reshape113_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2174_out1: [i64; 2] = [0i64, 0i64];
        let constant2175_out1: [i64; 1] = [-1i64];
        let concat57_out1: [i64; 4usize] = [
            &constant2174_out1[..],
            &unsqueeze32_out1[..],
            &constant2175_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape114_out1 = slice55_out1.reshape(concat57_out1);
        let slice56_out1 = reshape114_out1.slice(s![.., .., .., 0..unsqueeze32_out1[0]]);
        let constant2178_out1 = self.constant2178.val();
        let mul192_out1 = slice56_out1
            .mul((constant2178_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention28_out1,) = {
            let q = add164_out1;
            let k = linear248_out1;
            let v = linear249_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul192_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention28_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention28_out1 = {
                let dims = attention28_out1.dims();
                attention28_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention28_out1 = attention28_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention28_out1,)
        };
        let linear251_out1 = self.linear251.forward(attention28_out1);
        let add166_out1 = add163_out1.add(linear251_out1);
        let layernormalization138_out1 = {
            let dtype = add166_out1.clone().dtype();
            self.layernormalization138
                .forward(add166_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose113_out1 = layernormalization138_out1.permute([0, 2, 1]);
        let conv1d82_out1 = self.conv1d82.forward(transpose113_out1);
        let split_tensors = conv1d82_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split28_out1, split28_out2] = split_tensors.try_into().unwrap();
        let sigmoid110_out1 = burn::tensor::activation::sigmoid(split28_out2);
        let mul193_out1 = split28_out1.mul(sigmoid110_out1);
        let conv1d83_out1 = self.conv1d83.forward(mul193_out1);
        let sigmoid111_out1 = burn::tensor::activation::sigmoid(conv1d83_out1.clone());
        let mul194_out1 = conv1d83_out1.mul(sigmoid111_out1);
        let conv1d84_out1 = self.conv1d84.forward(mul194_out1);
        let transpose114_out1 = conv1d84_out1.permute([0, 2, 1]);
        let add167_out1 = add166_out1.add(transpose114_out1);
        let layernormalization139_out1 = {
            let dtype = add167_out1.clone().dtype();
            self.layernormalization139
                .forward(add167_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear252_out1 = self.linear252.forward(layernormalization139_out1);
        let sigmoid112_out1 = burn::tensor::activation::sigmoid(linear252_out1.clone());
        let mul195_out1 = linear252_out1.mul(sigmoid112_out1);
        let linear253_out1 = self.linear253.forward(mul195_out1);
        let constant2180_out1 = self.constant2180.val();
        let mul196_out1 = linear253_out1
            .mul((constant2180_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add168_out1 = add167_out1.add(mul196_out1);
        add168_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule24 {
    layernormalization140: LayerNorm,
    layernormalization141: LayerNorm,
    linear254: Linear,
    linear255: Linear,
    constant2181: burn::module::Param<Tensor<1>>,
    layernormalization142: LayerNorm,
    linear256: Linear,
    linear257: Linear,
    linear258: Linear,
    constant1008: burn::module::Param<Tensor<1>>,
    constant1009: burn::module::Param<Tensor<4>>,
    linear259: Linear,
    constant2195: burn::module::Param<Tensor<1>>,
    linear260: Linear,
    layernormalization143: LayerNorm,
    conv1d85: Conv1d,
    conv1d86: Conv1d,
    conv1d87: Conv1d,
    layernormalization144: LayerNorm,
    linear261: Linear,
    linear262: Linear,
    constant2197: burn::module::Param<Tensor<1>>,
    layernormalization145: LayerNorm,
    layernormalization146: LayerNorm,
    linear263: Linear,
    linear264: Linear,
    constant2198: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule24 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization140 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization141 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear254 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear255 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2181: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization142 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear256 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear257 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear258 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1008: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1009: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear259 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2195: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear260 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization143 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d85 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d86 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d87 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization144 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear261 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear262 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2197: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization145 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization146 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear263 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear264 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2198: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization140,
            layernormalization141,
            linear254,
            linear255,
            constant2181,
            layernormalization142,
            linear256,
            linear257,
            linear258,
            constant1008,
            constant1009,
            linear259,
            constant2195,
            linear260,
            layernormalization143,
            conv1d85,
            conv1d86,
            conv1d87,
            layernormalization144,
            linear261,
            linear262,
            constant2197,
            layernormalization145,
            layernormalization146,
            linear263,
            linear264,
            constant2198,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add168_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization140_out1 = {
            let dtype = add168_out1.dtype();
            self.layernormalization140
                .forward(add168_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization141_out1 = {
            let dtype = layernormalization140_out1.clone().dtype();
            self.layernormalization141
                .forward(
                    layernormalization140_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear254_out1 = self.linear254.forward(layernormalization141_out1);
        let sigmoid113_out1 = burn::tensor::activation::sigmoid(linear254_out1.clone());
        let mul197_out1 = linear254_out1.mul(sigmoid113_out1);
        let linear255_out1 = self.linear255.forward(mul197_out1);
        let constant2181_out1 = self.constant2181.val();
        let mul198_out1 = linear255_out1
            .mul((constant2181_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add169_out1 = layernormalization140_out1.add(mul198_out1);
        let layernormalization142_out1 = {
            let dtype = add169_out1.clone().dtype();
            self.layernormalization142
                .forward(add169_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear256_out1 = self.linear256.forward(layernormalization142_out1.clone());
        let linear257_out1 = self.linear257.forward(layernormalization142_out1.clone());
        let linear258_out1 = self.linear258.forward(layernormalization142_out1);
        let constant1008_out1 = self.constant1008.val();
        let add170_out1 = linear256_out1
            .clone()
            .add((constant1008_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape115_out1 = linear256_out1.reshape([0, -1, 8, 160]);
        let transpose115_out1 = reshape115_out1.permute([0, 2, 1, 3]);
        let constant1009_out1 = self.constant1009.val();
        let add171_out1 = transpose115_out1.clone().add(constant1009_out1);
        let linear259_out1 = self.linear259.forward(reshape2_out1);
        let reshape116_out1 = linear259_out1.reshape([0, -1, 8, 160]);
        let transpose116_out1 = reshape116_out1.permute([0, 2, 3, 1]);
        let matmul289_out1 = add171_out1.matmul(transpose116_out1);
        let pad29_out1 = matmul289_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape30_out1: [i64; 4] = {
            let axes = &transpose115_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather30_out1 = shape30_out1[2] as i64;
        let unsqueeze33_out1 = [gather30_out1 as i64];
        let constant2187_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat58_out1: [i64; 4usize] = [
            &constant2187_out1[..],
            &unsqueeze33_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape117_out1 = pad29_out1.reshape(concat58_out1);
        let slice57_out1 = reshape117_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2191_out1: [i64; 2] = [0i64, 0i64];
        let constant2192_out1: [i64; 1] = [-1i64];
        let concat59_out1: [i64; 4usize] = [
            &constant2191_out1[..],
            &unsqueeze33_out1[..],
            &constant2192_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape118_out1 = slice57_out1.reshape(concat59_out1);
        let slice58_out1 = reshape118_out1.slice(s![.., .., .., 0..unsqueeze33_out1[0]]);
        let constant2195_out1 = self.constant2195.val();
        let mul199_out1 = slice58_out1
            .mul((constant2195_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention29_out1,) = {
            let q = add170_out1;
            let k = linear257_out1;
            let v = linear258_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul199_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention29_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention29_out1 = {
                let dims = attention29_out1.dims();
                attention29_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention29_out1 = attention29_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention29_out1,)
        };
        let linear260_out1 = self.linear260.forward(attention29_out1);
        let add172_out1 = add169_out1.add(linear260_out1);
        let layernormalization143_out1 = {
            let dtype = add172_out1.clone().dtype();
            self.layernormalization143
                .forward(add172_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose117_out1 = layernormalization143_out1.permute([0, 2, 1]);
        let conv1d85_out1 = self.conv1d85.forward(transpose117_out1);
        let split_tensors = conv1d85_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split29_out1, split29_out2] = split_tensors.try_into().unwrap();
        let sigmoid114_out1 = burn::tensor::activation::sigmoid(split29_out2);
        let mul200_out1 = split29_out1.mul(sigmoid114_out1);
        let conv1d86_out1 = self.conv1d86.forward(mul200_out1);
        let sigmoid115_out1 = burn::tensor::activation::sigmoid(conv1d86_out1.clone());
        let mul201_out1 = conv1d86_out1.mul(sigmoid115_out1);
        let conv1d87_out1 = self.conv1d87.forward(mul201_out1);
        let transpose118_out1 = conv1d87_out1.permute([0, 2, 1]);
        let add173_out1 = add172_out1.add(transpose118_out1);
        let layernormalization144_out1 = {
            let dtype = add173_out1.clone().dtype();
            self.layernormalization144
                .forward(add173_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear261_out1 = self.linear261.forward(layernormalization144_out1);
        let sigmoid116_out1 = burn::tensor::activation::sigmoid(linear261_out1.clone());
        let mul202_out1 = linear261_out1.mul(sigmoid116_out1);
        let linear262_out1 = self.linear262.forward(mul202_out1);
        let constant2197_out1 = self.constant2197.val();
        let mul203_out1 = linear262_out1
            .mul((constant2197_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add174_out1 = add173_out1.add(mul203_out1);
        let layernormalization145_out1 = {
            let dtype = add174_out1.dtype();
            self.layernormalization145
                .forward(add174_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization146_out1 = {
            let dtype = layernormalization145_out1.clone().dtype();
            self.layernormalization146
                .forward(
                    layernormalization145_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear263_out1 = self.linear263.forward(layernormalization146_out1);
        let sigmoid117_out1 = burn::tensor::activation::sigmoid(linear263_out1.clone());
        let mul204_out1 = linear263_out1.mul(sigmoid117_out1);
        let linear264_out1 = self.linear264.forward(mul204_out1);
        let constant2198_out1 = self.constant2198.val();
        let mul205_out1 = linear264_out1
            .mul((constant2198_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add175_out1 = layernormalization145_out1.add(mul205_out1);
        add175_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule25 {
    layernormalization147: LayerNorm,
    linear265: Linear,
    linear266: Linear,
    linear267: Linear,
    constant1043: burn::module::Param<Tensor<1>>,
    constant1044: burn::module::Param<Tensor<4>>,
    linear268: Linear,
    constant2212: burn::module::Param<Tensor<1>>,
    linear269: Linear,
    layernormalization148: LayerNorm,
    conv1d88: Conv1d,
    conv1d89: Conv1d,
    conv1d90: Conv1d,
    layernormalization149: LayerNorm,
    linear270: Linear,
    linear271: Linear,
    constant2214: burn::module::Param<Tensor<1>>,
    layernormalization150: LayerNorm,
    layernormalization151: LayerNorm,
    linear272: Linear,
    linear273: Linear,
    constant2215: burn::module::Param<Tensor<1>>,
    layernormalization152: LayerNorm,
    linear274: Linear,
    linear275: Linear,
    linear276: Linear,
    constant1078: burn::module::Param<Tensor<1>>,
    constant1079: burn::module::Param<Tensor<4>>,
    linear277: Linear,
    constant2229: burn::module::Param<Tensor<1>>,
    linear278: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule25 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization147 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear265 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear266 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear267 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1043: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1044: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear268 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2212: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear269 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization148 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d88 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d89 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d90 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization149 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear270 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear271 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2214: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization150 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization151 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear272 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear273 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2215: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization152 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear274 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear275 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear276 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1078: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1079: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear277 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2229: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear278 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization147,
            linear265,
            linear266,
            linear267,
            constant1043,
            constant1044,
            linear268,
            constant2212,
            linear269,
            layernormalization148,
            conv1d88,
            conv1d89,
            conv1d90,
            layernormalization149,
            linear270,
            linear271,
            constant2214,
            layernormalization150,
            layernormalization151,
            linear272,
            linear273,
            constant2215,
            layernormalization152,
            linear274,
            linear275,
            linear276,
            constant1078,
            constant1079,
            linear277,
            constant2229,
            linear278,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add175_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization147_out1 = {
            let dtype = add175_out1.clone().dtype();
            self.layernormalization147
                .forward(add175_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear265_out1 = self.linear265.forward(layernormalization147_out1.clone());
        let linear266_out1 = self.linear266.forward(layernormalization147_out1.clone());
        let linear267_out1 = self.linear267.forward(layernormalization147_out1);
        let constant1043_out1 = self.constant1043.val();
        let add176_out1 = linear265_out1
            .clone()
            .add((constant1043_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape119_out1 = linear265_out1.reshape([0, -1, 8, 160]);
        let transpose119_out1 = reshape119_out1.permute([0, 2, 1, 3]);
        let constant1044_out1 = self.constant1044.val();
        let add177_out1 = transpose119_out1.clone().add(constant1044_out1);
        let linear268_out1 = self.linear268.forward(reshape2_out1.clone());
        let reshape120_out1 = linear268_out1.reshape([0, -1, 8, 160]);
        let transpose120_out1 = reshape120_out1.permute([0, 2, 3, 1]);
        let matmul299_out1 = add177_out1.matmul(transpose120_out1);
        let pad30_out1 = matmul299_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape31_out1: [i64; 4] = {
            let axes = &transpose119_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather31_out1 = shape31_out1[2] as i64;
        let unsqueeze34_out1 = [gather31_out1 as i64];
        let constant2204_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat60_out1: [i64; 4usize] = [
            &constant2204_out1[..],
            &unsqueeze34_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape121_out1 = pad30_out1.reshape(concat60_out1);
        let slice59_out1 = reshape121_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2208_out1: [i64; 2] = [0i64, 0i64];
        let constant2209_out1: [i64; 1] = [-1i64];
        let concat61_out1: [i64; 4usize] = [
            &constant2208_out1[..],
            &unsqueeze34_out1[..],
            &constant2209_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape122_out1 = slice59_out1.reshape(concat61_out1);
        let slice60_out1 = reshape122_out1.slice(s![.., .., .., 0..unsqueeze34_out1[0]]);
        let constant2212_out1 = self.constant2212.val();
        let mul206_out1 = slice60_out1
            .mul((constant2212_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention30_out1,) = {
            let q = add176_out1;
            let k = linear266_out1;
            let v = linear267_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul206_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention30_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention30_out1 = {
                let dims = attention30_out1.dims();
                attention30_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention30_out1 = attention30_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention30_out1,)
        };
        let linear269_out1 = self.linear269.forward(attention30_out1);
        let add178_out1 = add175_out1.add(linear269_out1);
        let layernormalization148_out1 = {
            let dtype = add178_out1.clone().dtype();
            self.layernormalization148
                .forward(add178_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose121_out1 = layernormalization148_out1.permute([0, 2, 1]);
        let conv1d88_out1 = self.conv1d88.forward(transpose121_out1);
        let split_tensors = conv1d88_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split30_out1, split30_out2] = split_tensors.try_into().unwrap();
        let sigmoid118_out1 = burn::tensor::activation::sigmoid(split30_out2);
        let mul207_out1 = split30_out1.mul(sigmoid118_out1);
        let conv1d89_out1 = self.conv1d89.forward(mul207_out1);
        let sigmoid119_out1 = burn::tensor::activation::sigmoid(conv1d89_out1.clone());
        let mul208_out1 = conv1d89_out1.mul(sigmoid119_out1);
        let conv1d90_out1 = self.conv1d90.forward(mul208_out1);
        let transpose122_out1 = conv1d90_out1.permute([0, 2, 1]);
        let add179_out1 = add178_out1.add(transpose122_out1);
        let layernormalization149_out1 = {
            let dtype = add179_out1.clone().dtype();
            self.layernormalization149
                .forward(add179_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear270_out1 = self.linear270.forward(layernormalization149_out1);
        let sigmoid120_out1 = burn::tensor::activation::sigmoid(linear270_out1.clone());
        let mul209_out1 = linear270_out1.mul(sigmoid120_out1);
        let linear271_out1 = self.linear271.forward(mul209_out1);
        let constant2214_out1 = self.constant2214.val();
        let mul210_out1 = linear271_out1
            .mul((constant2214_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add180_out1 = add179_out1.add(mul210_out1);
        let layernormalization150_out1 = {
            let dtype = add180_out1.dtype();
            self.layernormalization150
                .forward(add180_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization151_out1 = {
            let dtype = layernormalization150_out1.clone().dtype();
            self.layernormalization151
                .forward(
                    layernormalization150_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear272_out1 = self.linear272.forward(layernormalization151_out1);
        let sigmoid121_out1 = burn::tensor::activation::sigmoid(linear272_out1.clone());
        let mul211_out1 = linear272_out1.mul(sigmoid121_out1);
        let linear273_out1 = self.linear273.forward(mul211_out1);
        let constant2215_out1 = self.constant2215.val();
        let mul212_out1 = linear273_out1
            .mul((constant2215_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add181_out1 = layernormalization150_out1.add(mul212_out1);
        let layernormalization152_out1 = {
            let dtype = add181_out1.clone().dtype();
            self.layernormalization152
                .forward(add181_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear274_out1 = self.linear274.forward(layernormalization152_out1.clone());
        let linear275_out1 = self.linear275.forward(layernormalization152_out1.clone());
        let linear276_out1 = self.linear276.forward(layernormalization152_out1);
        let constant1078_out1 = self.constant1078.val();
        let add182_out1 = linear274_out1
            .clone()
            .add((constant1078_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape123_out1 = linear274_out1.reshape([0, -1, 8, 160]);
        let transpose123_out1 = reshape123_out1.permute([0, 2, 1, 3]);
        let constant1079_out1 = self.constant1079.val();
        let add183_out1 = transpose123_out1.clone().add(constant1079_out1);
        let linear277_out1 = self.linear277.forward(reshape2_out1);
        let reshape124_out1 = linear277_out1.reshape([0, -1, 8, 160]);
        let transpose124_out1 = reshape124_out1.permute([0, 2, 3, 1]);
        let matmul309_out1 = add183_out1.matmul(transpose124_out1);
        let pad31_out1 = matmul309_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape32_out1: [i64; 4] = {
            let axes = &transpose123_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather32_out1 = shape32_out1[2] as i64;
        let unsqueeze35_out1 = [gather32_out1 as i64];
        let constant2221_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat62_out1: [i64; 4usize] = [
            &constant2221_out1[..],
            &unsqueeze35_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape125_out1 = pad31_out1.reshape(concat62_out1);
        let slice61_out1 = reshape125_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2225_out1: [i64; 2] = [0i64, 0i64];
        let constant2226_out1: [i64; 1] = [-1i64];
        let concat63_out1: [i64; 4usize] = [
            &constant2225_out1[..],
            &unsqueeze35_out1[..],
            &constant2226_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape126_out1 = slice61_out1.reshape(concat63_out1);
        let slice62_out1 = reshape126_out1.slice(s![.., .., .., 0..unsqueeze35_out1[0]]);
        let constant2229_out1 = self.constant2229.val();
        let mul213_out1 = slice62_out1
            .mul((constant2229_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention31_out1,) = {
            let q = add182_out1;
            let k = linear275_out1;
            let v = linear276_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul213_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention31_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention31_out1 = {
                let dims = attention31_out1.dims();
                attention31_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention31_out1 = attention31_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention31_out1,)
        };
        let linear278_out1 = self.linear278.forward(attention31_out1);
        let add184_out1 = add181_out1.add(linear278_out1);
        add184_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule26 {
    layernormalization153: LayerNorm,
    conv1d91: Conv1d,
    conv1d92: Conv1d,
    conv1d93: Conv1d,
    layernormalization154: LayerNorm,
    linear279: Linear,
    linear280: Linear,
    constant2231: burn::module::Param<Tensor<1>>,
    layernormalization155: LayerNorm,
    layernormalization156: LayerNorm,
    linear281: Linear,
    linear282: Linear,
    constant2232: burn::module::Param<Tensor<1>>,
    layernormalization157: LayerNorm,
    linear283: Linear,
    linear284: Linear,
    linear285: Linear,
    constant1113: burn::module::Param<Tensor<1>>,
    constant1114: burn::module::Param<Tensor<4>>,
    linear286: Linear,
    constant2246: burn::module::Param<Tensor<1>>,
    linear287: Linear,
    layernormalization158: LayerNorm,
    conv1d94: Conv1d,
    conv1d95: Conv1d,
    conv1d96: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule26 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization153 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d91 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d92 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d93 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization154 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear279 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear280 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2231: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization155 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization156 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear281 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear282 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2232: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization157 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear283 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear284 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear285 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1113: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1114: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear286 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2246: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear287 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization158 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d94 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d95 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d96 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization153,
            conv1d91,
            conv1d92,
            conv1d93,
            layernormalization154,
            linear279,
            linear280,
            constant2231,
            layernormalization155,
            layernormalization156,
            linear281,
            linear282,
            constant2232,
            layernormalization157,
            linear283,
            linear284,
            linear285,
            constant1113,
            constant1114,
            linear286,
            constant2246,
            linear287,
            layernormalization158,
            conv1d94,
            conv1d95,
            conv1d96,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add184_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization153_out1 = {
            let dtype = add184_out1.clone().dtype();
            self.layernormalization153
                .forward(add184_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose125_out1 = layernormalization153_out1.permute([0, 2, 1]);
        let conv1d91_out1 = self.conv1d91.forward(transpose125_out1);
        let split_tensors = conv1d91_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split31_out1, split31_out2] = split_tensors.try_into().unwrap();
        let sigmoid122_out1 = burn::tensor::activation::sigmoid(split31_out2);
        let mul214_out1 = split31_out1.mul(sigmoid122_out1);
        let conv1d92_out1 = self.conv1d92.forward(mul214_out1);
        let sigmoid123_out1 = burn::tensor::activation::sigmoid(conv1d92_out1.clone());
        let mul215_out1 = conv1d92_out1.mul(sigmoid123_out1);
        let conv1d93_out1 = self.conv1d93.forward(mul215_out1);
        let transpose126_out1 = conv1d93_out1.permute([0, 2, 1]);
        let add185_out1 = add184_out1.add(transpose126_out1);
        let layernormalization154_out1 = {
            let dtype = add185_out1.clone().dtype();
            self.layernormalization154
                .forward(add185_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear279_out1 = self.linear279.forward(layernormalization154_out1);
        let sigmoid124_out1 = burn::tensor::activation::sigmoid(linear279_out1.clone());
        let mul216_out1 = linear279_out1.mul(sigmoid124_out1);
        let linear280_out1 = self.linear280.forward(mul216_out1);
        let constant2231_out1 = self.constant2231.val();
        let mul217_out1 = linear280_out1
            .mul((constant2231_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add186_out1 = add185_out1.add(mul217_out1);
        let layernormalization155_out1 = {
            let dtype = add186_out1.dtype();
            self.layernormalization155
                .forward(add186_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization156_out1 = {
            let dtype = layernormalization155_out1.clone().dtype();
            self.layernormalization156
                .forward(
                    layernormalization155_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear281_out1 = self.linear281.forward(layernormalization156_out1);
        let sigmoid125_out1 = burn::tensor::activation::sigmoid(linear281_out1.clone());
        let mul218_out1 = linear281_out1.mul(sigmoid125_out1);
        let linear282_out1 = self.linear282.forward(mul218_out1);
        let constant2232_out1 = self.constant2232.val();
        let mul219_out1 = linear282_out1
            .mul((constant2232_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add187_out1 = layernormalization155_out1.add(mul219_out1);
        let layernormalization157_out1 = {
            let dtype = add187_out1.clone().dtype();
            self.layernormalization157
                .forward(add187_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear283_out1 = self.linear283.forward(layernormalization157_out1.clone());
        let linear284_out1 = self.linear284.forward(layernormalization157_out1.clone());
        let linear285_out1 = self.linear285.forward(layernormalization157_out1);
        let constant1113_out1 = self.constant1113.val();
        let add188_out1 = linear283_out1
            .clone()
            .add((constant1113_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape127_out1 = linear283_out1.reshape([0, -1, 8, 160]);
        let transpose127_out1 = reshape127_out1.permute([0, 2, 1, 3]);
        let constant1114_out1 = self.constant1114.val();
        let add189_out1 = transpose127_out1.clone().add(constant1114_out1);
        let linear286_out1 = self.linear286.forward(reshape2_out1);
        let reshape128_out1 = linear286_out1.reshape([0, -1, 8, 160]);
        let transpose128_out1 = reshape128_out1.permute([0, 2, 3, 1]);
        let matmul319_out1 = add189_out1.matmul(transpose128_out1);
        let pad32_out1 = matmul319_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape33_out1: [i64; 4] = {
            let axes = &transpose127_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather33_out1 = shape33_out1[2] as i64;
        let unsqueeze36_out1 = [gather33_out1 as i64];
        let constant2238_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat64_out1: [i64; 4usize] = [
            &constant2238_out1[..],
            &unsqueeze36_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape129_out1 = pad32_out1.reshape(concat64_out1);
        let slice63_out1 = reshape129_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2242_out1: [i64; 2] = [0i64, 0i64];
        let constant2243_out1: [i64; 1] = [-1i64];
        let concat65_out1: [i64; 4usize] = [
            &constant2242_out1[..],
            &unsqueeze36_out1[..],
            &constant2243_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape130_out1 = slice63_out1.reshape(concat65_out1);
        let slice64_out1 = reshape130_out1.slice(s![.., .., .., 0..unsqueeze36_out1[0]]);
        let constant2246_out1 = self.constant2246.val();
        let mul220_out1 = slice64_out1
            .mul((constant2246_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention32_out1,) = {
            let q = add188_out1;
            let k = linear284_out1;
            let v = linear285_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul220_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention32_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention32_out1 = {
                let dims = attention32_out1.dims();
                attention32_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention32_out1 = attention32_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention32_out1,)
        };
        let linear287_out1 = self.linear287.forward(attention32_out1);
        let add190_out1 = add187_out1.add(linear287_out1);
        let layernormalization158_out1 = {
            let dtype = add190_out1.clone().dtype();
            self.layernormalization158
                .forward(add190_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose129_out1 = layernormalization158_out1.permute([0, 2, 1]);
        let conv1d94_out1 = self.conv1d94.forward(transpose129_out1);
        let split_tensors = conv1d94_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split32_out1, split32_out2] = split_tensors.try_into().unwrap();
        let sigmoid126_out1 = burn::tensor::activation::sigmoid(split32_out2);
        let mul221_out1 = split32_out1.mul(sigmoid126_out1);
        let conv1d95_out1 = self.conv1d95.forward(mul221_out1);
        let sigmoid127_out1 = burn::tensor::activation::sigmoid(conv1d95_out1.clone());
        let mul222_out1 = conv1d95_out1.mul(sigmoid127_out1);
        let conv1d96_out1 = self.conv1d96.forward(mul222_out1);
        let transpose130_out1 = conv1d96_out1.permute([0, 2, 1]);
        let add191_out1 = add190_out1.add(transpose130_out1);
        add191_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule27 {
    layernormalization159: LayerNorm,
    linear288: Linear,
    linear289: Linear,
    constant2248: burn::module::Param<Tensor<1>>,
    layernormalization160: LayerNorm,
    layernormalization161: LayerNorm,
    linear290: Linear,
    linear291: Linear,
    constant2249: burn::module::Param<Tensor<1>>,
    layernormalization162: LayerNorm,
    linear292: Linear,
    linear293: Linear,
    linear294: Linear,
    constant1148: burn::module::Param<Tensor<1>>,
    constant1149: burn::module::Param<Tensor<4>>,
    linear295: Linear,
    constant2263: burn::module::Param<Tensor<1>>,
    linear296: Linear,
    layernormalization163: LayerNorm,
    conv1d97: Conv1d,
    conv1d98: Conv1d,
    conv1d99: Conv1d,
    layernormalization164: LayerNorm,
    linear297: Linear,
    linear298: Linear,
    constant2265: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule27 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization159 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear288 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear289 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2248: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization160 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization161 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear290 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear291 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2249: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization162 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear292 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear293 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear294 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1148: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1149: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear295 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2263: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear296 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization163 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d97 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d98 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d99 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization164 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear297 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear298 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2265: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization159,
            linear288,
            linear289,
            constant2248,
            layernormalization160,
            layernormalization161,
            linear290,
            linear291,
            constant2249,
            layernormalization162,
            linear292,
            linear293,
            linear294,
            constant1148,
            constant1149,
            linear295,
            constant2263,
            linear296,
            layernormalization163,
            conv1d97,
            conv1d98,
            conv1d99,
            layernormalization164,
            linear297,
            linear298,
            constant2265,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add191_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization159_out1 = {
            let dtype = add191_out1.clone().dtype();
            self.layernormalization159
                .forward(add191_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear288_out1 = self.linear288.forward(layernormalization159_out1);
        let sigmoid128_out1 = burn::tensor::activation::sigmoid(linear288_out1.clone());
        let mul223_out1 = linear288_out1.mul(sigmoid128_out1);
        let linear289_out1 = self.linear289.forward(mul223_out1);
        let constant2248_out1 = self.constant2248.val();
        let mul224_out1 = linear289_out1
            .mul((constant2248_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add192_out1 = add191_out1.add(mul224_out1);
        let layernormalization160_out1 = {
            let dtype = add192_out1.dtype();
            self.layernormalization160
                .forward(add192_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization161_out1 = {
            let dtype = layernormalization160_out1.clone().dtype();
            self.layernormalization161
                .forward(
                    layernormalization160_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear290_out1 = self.linear290.forward(layernormalization161_out1);
        let sigmoid129_out1 = burn::tensor::activation::sigmoid(linear290_out1.clone());
        let mul225_out1 = linear290_out1.mul(sigmoid129_out1);
        let linear291_out1 = self.linear291.forward(mul225_out1);
        let constant2249_out1 = self.constant2249.val();
        let mul226_out1 = linear291_out1
            .mul((constant2249_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add193_out1 = layernormalization160_out1.add(mul226_out1);
        let layernormalization162_out1 = {
            let dtype = add193_out1.clone().dtype();
            self.layernormalization162
                .forward(add193_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear292_out1 = self.linear292.forward(layernormalization162_out1.clone());
        let linear293_out1 = self.linear293.forward(layernormalization162_out1.clone());
        let linear294_out1 = self.linear294.forward(layernormalization162_out1);
        let constant1148_out1 = self.constant1148.val();
        let add194_out1 = linear292_out1
            .clone()
            .add((constant1148_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape131_out1 = linear292_out1.reshape([0, -1, 8, 160]);
        let transpose131_out1 = reshape131_out1.permute([0, 2, 1, 3]);
        let constant1149_out1 = self.constant1149.val();
        let add195_out1 = transpose131_out1.clone().add(constant1149_out1);
        let linear295_out1 = self.linear295.forward(reshape2_out1);
        let reshape132_out1 = linear295_out1.reshape([0, -1, 8, 160]);
        let transpose132_out1 = reshape132_out1.permute([0, 2, 3, 1]);
        let matmul329_out1 = add195_out1.matmul(transpose132_out1);
        let pad33_out1 = matmul329_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape34_out1: [i64; 4] = {
            let axes = &transpose131_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather34_out1 = shape34_out1[2] as i64;
        let unsqueeze37_out1 = [gather34_out1 as i64];
        let constant2255_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat66_out1: [i64; 4usize] = [
            &constant2255_out1[..],
            &unsqueeze37_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape133_out1 = pad33_out1.reshape(concat66_out1);
        let slice65_out1 = reshape133_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2259_out1: [i64; 2] = [0i64, 0i64];
        let constant2260_out1: [i64; 1] = [-1i64];
        let concat67_out1: [i64; 4usize] = [
            &constant2259_out1[..],
            &unsqueeze37_out1[..],
            &constant2260_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape134_out1 = slice65_out1.reshape(concat67_out1);
        let slice66_out1 = reshape134_out1.slice(s![.., .., .., 0..unsqueeze37_out1[0]]);
        let constant2263_out1 = self.constant2263.val();
        let mul227_out1 = slice66_out1
            .mul((constant2263_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention33_out1,) = {
            let q = add194_out1;
            let k = linear293_out1;
            let v = linear294_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul227_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention33_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention33_out1 = {
                let dims = attention33_out1.dims();
                attention33_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention33_out1 = attention33_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention33_out1,)
        };
        let linear296_out1 = self.linear296.forward(attention33_out1);
        let add196_out1 = add193_out1.add(linear296_out1);
        let layernormalization163_out1 = {
            let dtype = add196_out1.clone().dtype();
            self.layernormalization163
                .forward(add196_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose133_out1 = layernormalization163_out1.permute([0, 2, 1]);
        let conv1d97_out1 = self.conv1d97.forward(transpose133_out1);
        let split_tensors = conv1d97_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split33_out1, split33_out2] = split_tensors.try_into().unwrap();
        let sigmoid130_out1 = burn::tensor::activation::sigmoid(split33_out2);
        let mul228_out1 = split33_out1.mul(sigmoid130_out1);
        let conv1d98_out1 = self.conv1d98.forward(mul228_out1);
        let sigmoid131_out1 = burn::tensor::activation::sigmoid(conv1d98_out1.clone());
        let mul229_out1 = conv1d98_out1.mul(sigmoid131_out1);
        let conv1d99_out1 = self.conv1d99.forward(mul229_out1);
        let transpose134_out1 = conv1d99_out1.permute([0, 2, 1]);
        let add197_out1 = add196_out1.add(transpose134_out1);
        let layernormalization164_out1 = {
            let dtype = add197_out1.clone().dtype();
            self.layernormalization164
                .forward(add197_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear297_out1 = self.linear297.forward(layernormalization164_out1);
        let sigmoid132_out1 = burn::tensor::activation::sigmoid(linear297_out1.clone());
        let mul230_out1 = linear297_out1.mul(sigmoid132_out1);
        let linear298_out1 = self.linear298.forward(mul230_out1);
        let constant2265_out1 = self.constant2265.val();
        let mul231_out1 = linear298_out1
            .mul((constant2265_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add198_out1 = add197_out1.add(mul231_out1);
        add198_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule28 {
    layernormalization165: LayerNorm,
    layernormalization166: LayerNorm,
    linear299: Linear,
    linear300: Linear,
    constant2266: burn::module::Param<Tensor<1>>,
    layernormalization167: LayerNorm,
    linear301: Linear,
    linear302: Linear,
    linear303: Linear,
    constant1183: burn::module::Param<Tensor<1>>,
    constant1184: burn::module::Param<Tensor<4>>,
    linear304: Linear,
    constant2280: burn::module::Param<Tensor<1>>,
    linear305: Linear,
    layernormalization168: LayerNorm,
    conv1d100: Conv1d,
    conv1d101: Conv1d,
    conv1d102: Conv1d,
    layernormalization169: LayerNorm,
    linear306: Linear,
    linear307: Linear,
    constant2282: burn::module::Param<Tensor<1>>,
    layernormalization170: LayerNorm,
    layernormalization171: LayerNorm,
    linear308: Linear,
    linear309: Linear,
    constant2283: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule28 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization165 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization166 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear299 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear300 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2266: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization167 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear301 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear302 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear303 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1183: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1184: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear304 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2280: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear305 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization168 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d100 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d101 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d102 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization169 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear306 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear307 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2282: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization170 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization171 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear308 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear309 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2283: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization165,
            layernormalization166,
            linear299,
            linear300,
            constant2266,
            layernormalization167,
            linear301,
            linear302,
            linear303,
            constant1183,
            constant1184,
            linear304,
            constant2280,
            linear305,
            layernormalization168,
            conv1d100,
            conv1d101,
            conv1d102,
            layernormalization169,
            linear306,
            linear307,
            constant2282,
            layernormalization170,
            layernormalization171,
            linear308,
            linear309,
            constant2283,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add198_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization165_out1 = {
            let dtype = add198_out1.dtype();
            self.layernormalization165
                .forward(add198_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization166_out1 = {
            let dtype = layernormalization165_out1.clone().dtype();
            self.layernormalization166
                .forward(
                    layernormalization165_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear299_out1 = self.linear299.forward(layernormalization166_out1);
        let sigmoid133_out1 = burn::tensor::activation::sigmoid(linear299_out1.clone());
        let mul232_out1 = linear299_out1.mul(sigmoid133_out1);
        let linear300_out1 = self.linear300.forward(mul232_out1);
        let constant2266_out1 = self.constant2266.val();
        let mul233_out1 = linear300_out1
            .mul((constant2266_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add199_out1 = layernormalization165_out1.add(mul233_out1);
        let layernormalization167_out1 = {
            let dtype = add199_out1.clone().dtype();
            self.layernormalization167
                .forward(add199_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear301_out1 = self.linear301.forward(layernormalization167_out1.clone());
        let linear302_out1 = self.linear302.forward(layernormalization167_out1.clone());
        let linear303_out1 = self.linear303.forward(layernormalization167_out1);
        let constant1183_out1 = self.constant1183.val();
        let add200_out1 = linear301_out1
            .clone()
            .add((constant1183_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape135_out1 = linear301_out1.reshape([0, -1, 8, 160]);
        let transpose135_out1 = reshape135_out1.permute([0, 2, 1, 3]);
        let constant1184_out1 = self.constant1184.val();
        let add201_out1 = transpose135_out1.clone().add(constant1184_out1);
        let linear304_out1 = self.linear304.forward(reshape2_out1);
        let reshape136_out1 = linear304_out1.reshape([0, -1, 8, 160]);
        let transpose136_out1 = reshape136_out1.permute([0, 2, 3, 1]);
        let matmul339_out1 = add201_out1.matmul(transpose136_out1);
        let pad34_out1 = matmul339_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape35_out1: [i64; 4] = {
            let axes = &transpose135_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather35_out1 = shape35_out1[2] as i64;
        let unsqueeze38_out1 = [gather35_out1 as i64];
        let constant2272_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat68_out1: [i64; 4usize] = [
            &constant2272_out1[..],
            &unsqueeze38_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape137_out1 = pad34_out1.reshape(concat68_out1);
        let slice67_out1 = reshape137_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2276_out1: [i64; 2] = [0i64, 0i64];
        let constant2277_out1: [i64; 1] = [-1i64];
        let concat69_out1: [i64; 4usize] = [
            &constant2276_out1[..],
            &unsqueeze38_out1[..],
            &constant2277_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape138_out1 = slice67_out1.reshape(concat69_out1);
        let slice68_out1 = reshape138_out1.slice(s![.., .., .., 0..unsqueeze38_out1[0]]);
        let constant2280_out1 = self.constant2280.val();
        let mul234_out1 = slice68_out1
            .mul((constant2280_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention34_out1,) = {
            let q = add200_out1;
            let k = linear302_out1;
            let v = linear303_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul234_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention34_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention34_out1 = {
                let dims = attention34_out1.dims();
                attention34_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention34_out1 = attention34_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention34_out1,)
        };
        let linear305_out1 = self.linear305.forward(attention34_out1);
        let add202_out1 = add199_out1.add(linear305_out1);
        let layernormalization168_out1 = {
            let dtype = add202_out1.clone().dtype();
            self.layernormalization168
                .forward(add202_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose137_out1 = layernormalization168_out1.permute([0, 2, 1]);
        let conv1d100_out1 = self.conv1d100.forward(transpose137_out1);
        let split_tensors = conv1d100_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split34_out1, split34_out2] = split_tensors.try_into().unwrap();
        let sigmoid134_out1 = burn::tensor::activation::sigmoid(split34_out2);
        let mul235_out1 = split34_out1.mul(sigmoid134_out1);
        let conv1d101_out1 = self.conv1d101.forward(mul235_out1);
        let sigmoid135_out1 = burn::tensor::activation::sigmoid(conv1d101_out1.clone());
        let mul236_out1 = conv1d101_out1.mul(sigmoid135_out1);
        let conv1d102_out1 = self.conv1d102.forward(mul236_out1);
        let transpose138_out1 = conv1d102_out1.permute([0, 2, 1]);
        let add203_out1 = add202_out1.add(transpose138_out1);
        let layernormalization169_out1 = {
            let dtype = add203_out1.clone().dtype();
            self.layernormalization169
                .forward(add203_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear306_out1 = self.linear306.forward(layernormalization169_out1);
        let sigmoid136_out1 = burn::tensor::activation::sigmoid(linear306_out1.clone());
        let mul237_out1 = linear306_out1.mul(sigmoid136_out1);
        let linear307_out1 = self.linear307.forward(mul237_out1);
        let constant2282_out1 = self.constant2282.val();
        let mul238_out1 = linear307_out1
            .mul((constant2282_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add204_out1 = add203_out1.add(mul238_out1);
        let layernormalization170_out1 = {
            let dtype = add204_out1.dtype();
            self.layernormalization170
                .forward(add204_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization171_out1 = {
            let dtype = layernormalization170_out1.clone().dtype();
            self.layernormalization171
                .forward(
                    layernormalization170_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear308_out1 = self.linear308.forward(layernormalization171_out1);
        let sigmoid137_out1 = burn::tensor::activation::sigmoid(linear308_out1.clone());
        let mul239_out1 = linear308_out1.mul(sigmoid137_out1);
        let linear309_out1 = self.linear309.forward(mul239_out1);
        let constant2283_out1 = self.constant2283.val();
        let mul240_out1 = linear309_out1
            .mul((constant2283_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add205_out1 = layernormalization170_out1.add(mul240_out1);
        add205_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule29 {
    layernormalization172: LayerNorm,
    linear310: Linear,
    linear311: Linear,
    linear312: Linear,
    constant1218: burn::module::Param<Tensor<1>>,
    constant1219: burn::module::Param<Tensor<4>>,
    linear313: Linear,
    constant2297: burn::module::Param<Tensor<1>>,
    linear314: Linear,
    layernormalization173: LayerNorm,
    conv1d103: Conv1d,
    conv1d104: Conv1d,
    conv1d105: Conv1d,
    layernormalization174: LayerNorm,
    linear315: Linear,
    linear316: Linear,
    constant2299: burn::module::Param<Tensor<1>>,
    layernormalization175: LayerNorm,
    layernormalization176: LayerNorm,
    linear317: Linear,
    linear318: Linear,
    constant2300: burn::module::Param<Tensor<1>>,
    layernormalization177: LayerNorm,
    linear319: Linear,
    linear320: Linear,
    linear321: Linear,
    constant1253: burn::module::Param<Tensor<1>>,
    constant1254: burn::module::Param<Tensor<4>>,
    linear322: Linear,
    constant2314: burn::module::Param<Tensor<1>>,
    linear323: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule29 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization172 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear310 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear311 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear312 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1218: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1219: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear313 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2297: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear314 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization173 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d103 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d104 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d105 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization174 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear315 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear316 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2299: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization175 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization176 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear317 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear318 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2300: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization177 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear319 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear320 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear321 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1253: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1254: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear322 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2314: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear323 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization172,
            linear310,
            linear311,
            linear312,
            constant1218,
            constant1219,
            linear313,
            constant2297,
            linear314,
            layernormalization173,
            conv1d103,
            conv1d104,
            conv1d105,
            layernormalization174,
            linear315,
            linear316,
            constant2299,
            layernormalization175,
            layernormalization176,
            linear317,
            linear318,
            constant2300,
            layernormalization177,
            linear319,
            linear320,
            linear321,
            constant1253,
            constant1254,
            linear322,
            constant2314,
            linear323,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add205_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization172_out1 = {
            let dtype = add205_out1.clone().dtype();
            self.layernormalization172
                .forward(add205_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear310_out1 = self.linear310.forward(layernormalization172_out1.clone());
        let linear311_out1 = self.linear311.forward(layernormalization172_out1.clone());
        let linear312_out1 = self.linear312.forward(layernormalization172_out1);
        let constant1218_out1 = self.constant1218.val();
        let add206_out1 = linear310_out1
            .clone()
            .add((constant1218_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape139_out1 = linear310_out1.reshape([0, -1, 8, 160]);
        let transpose139_out1 = reshape139_out1.permute([0, 2, 1, 3]);
        let constant1219_out1 = self.constant1219.val();
        let add207_out1 = transpose139_out1.clone().add(constant1219_out1);
        let linear313_out1 = self.linear313.forward(reshape2_out1.clone());
        let reshape140_out1 = linear313_out1.reshape([0, -1, 8, 160]);
        let transpose140_out1 = reshape140_out1.permute([0, 2, 3, 1]);
        let matmul349_out1 = add207_out1.matmul(transpose140_out1);
        let pad35_out1 = matmul349_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape36_out1: [i64; 4] = {
            let axes = &transpose139_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather36_out1 = shape36_out1[2] as i64;
        let unsqueeze39_out1 = [gather36_out1 as i64];
        let constant2289_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat70_out1: [i64; 4usize] = [
            &constant2289_out1[..],
            &unsqueeze39_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape141_out1 = pad35_out1.reshape(concat70_out1);
        let slice69_out1 = reshape141_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2293_out1: [i64; 2] = [0i64, 0i64];
        let constant2294_out1: [i64; 1] = [-1i64];
        let concat71_out1: [i64; 4usize] = [
            &constant2293_out1[..],
            &unsqueeze39_out1[..],
            &constant2294_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape142_out1 = slice69_out1.reshape(concat71_out1);
        let slice70_out1 = reshape142_out1.slice(s![.., .., .., 0..unsqueeze39_out1[0]]);
        let constant2297_out1 = self.constant2297.val();
        let mul241_out1 = slice70_out1
            .mul((constant2297_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention35_out1,) = {
            let q = add206_out1;
            let k = linear311_out1;
            let v = linear312_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul241_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention35_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention35_out1 = {
                let dims = attention35_out1.dims();
                attention35_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention35_out1 = attention35_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention35_out1,)
        };
        let linear314_out1 = self.linear314.forward(attention35_out1);
        let add208_out1 = add205_out1.add(linear314_out1);
        let layernormalization173_out1 = {
            let dtype = add208_out1.clone().dtype();
            self.layernormalization173
                .forward(add208_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose141_out1 = layernormalization173_out1.permute([0, 2, 1]);
        let conv1d103_out1 = self.conv1d103.forward(transpose141_out1);
        let split_tensors = conv1d103_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split35_out1, split35_out2] = split_tensors.try_into().unwrap();
        let sigmoid138_out1 = burn::tensor::activation::sigmoid(split35_out2);
        let mul242_out1 = split35_out1.mul(sigmoid138_out1);
        let conv1d104_out1 = self.conv1d104.forward(mul242_out1);
        let sigmoid139_out1 = burn::tensor::activation::sigmoid(conv1d104_out1.clone());
        let mul243_out1 = conv1d104_out1.mul(sigmoid139_out1);
        let conv1d105_out1 = self.conv1d105.forward(mul243_out1);
        let transpose142_out1 = conv1d105_out1.permute([0, 2, 1]);
        let add209_out1 = add208_out1.add(transpose142_out1);
        let layernormalization174_out1 = {
            let dtype = add209_out1.clone().dtype();
            self.layernormalization174
                .forward(add209_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear315_out1 = self.linear315.forward(layernormalization174_out1);
        let sigmoid140_out1 = burn::tensor::activation::sigmoid(linear315_out1.clone());
        let mul244_out1 = linear315_out1.mul(sigmoid140_out1);
        let linear316_out1 = self.linear316.forward(mul244_out1);
        let constant2299_out1 = self.constant2299.val();
        let mul245_out1 = linear316_out1
            .mul((constant2299_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add210_out1 = add209_out1.add(mul245_out1);
        let layernormalization175_out1 = {
            let dtype = add210_out1.dtype();
            self.layernormalization175
                .forward(add210_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization176_out1 = {
            let dtype = layernormalization175_out1.clone().dtype();
            self.layernormalization176
                .forward(
                    layernormalization175_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear317_out1 = self.linear317.forward(layernormalization176_out1);
        let sigmoid141_out1 = burn::tensor::activation::sigmoid(linear317_out1.clone());
        let mul246_out1 = linear317_out1.mul(sigmoid141_out1);
        let linear318_out1 = self.linear318.forward(mul246_out1);
        let constant2300_out1 = self.constant2300.val();
        let mul247_out1 = linear318_out1
            .mul((constant2300_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add211_out1 = layernormalization175_out1.add(mul247_out1);
        let layernormalization177_out1 = {
            let dtype = add211_out1.clone().dtype();
            self.layernormalization177
                .forward(add211_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear319_out1 = self.linear319.forward(layernormalization177_out1.clone());
        let linear320_out1 = self.linear320.forward(layernormalization177_out1.clone());
        let linear321_out1 = self.linear321.forward(layernormalization177_out1);
        let constant1253_out1 = self.constant1253.val();
        let add212_out1 = linear319_out1
            .clone()
            .add((constant1253_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape143_out1 = linear319_out1.reshape([0, -1, 8, 160]);
        let transpose143_out1 = reshape143_out1.permute([0, 2, 1, 3]);
        let constant1254_out1 = self.constant1254.val();
        let add213_out1 = transpose143_out1.clone().add(constant1254_out1);
        let linear322_out1 = self.linear322.forward(reshape2_out1);
        let reshape144_out1 = linear322_out1.reshape([0, -1, 8, 160]);
        let transpose144_out1 = reshape144_out1.permute([0, 2, 3, 1]);
        let matmul359_out1 = add213_out1.matmul(transpose144_out1);
        let pad36_out1 = matmul359_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape37_out1: [i64; 4] = {
            let axes = &transpose143_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather37_out1 = shape37_out1[2] as i64;
        let unsqueeze40_out1 = [gather37_out1 as i64];
        let constant2306_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat72_out1: [i64; 4usize] = [
            &constant2306_out1[..],
            &unsqueeze40_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape145_out1 = pad36_out1.reshape(concat72_out1);
        let slice71_out1 = reshape145_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2310_out1: [i64; 2] = [0i64, 0i64];
        let constant2311_out1: [i64; 1] = [-1i64];
        let concat73_out1: [i64; 4usize] = [
            &constant2310_out1[..],
            &unsqueeze40_out1[..],
            &constant2311_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape146_out1 = slice71_out1.reshape(concat73_out1);
        let slice72_out1 = reshape146_out1.slice(s![.., .., .., 0..unsqueeze40_out1[0]]);
        let constant2314_out1 = self.constant2314.val();
        let mul248_out1 = slice72_out1
            .mul((constant2314_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention36_out1,) = {
            let q = add212_out1;
            let k = linear320_out1;
            let v = linear321_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul248_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention36_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention36_out1 = {
                let dims = attention36_out1.dims();
                attention36_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention36_out1 = attention36_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention36_out1,)
        };
        let linear323_out1 = self.linear323.forward(attention36_out1);
        let add214_out1 = add211_out1.add(linear323_out1);
        add214_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule30 {
    layernormalization178: LayerNorm,
    conv1d106: Conv1d,
    conv1d107: Conv1d,
    conv1d108: Conv1d,
    layernormalization179: LayerNorm,
    linear324: Linear,
    linear325: Linear,
    constant2316: burn::module::Param<Tensor<1>>,
    layernormalization180: LayerNorm,
    layernormalization181: LayerNorm,
    linear326: Linear,
    linear327: Linear,
    constant2317: burn::module::Param<Tensor<1>>,
    layernormalization182: LayerNorm,
    linear328: Linear,
    linear329: Linear,
    linear330: Linear,
    constant1288: burn::module::Param<Tensor<1>>,
    constant1289: burn::module::Param<Tensor<4>>,
    linear331: Linear,
    constant2331: burn::module::Param<Tensor<1>>,
    linear332: Linear,
    layernormalization183: LayerNorm,
    conv1d109: Conv1d,
    conv1d110: Conv1d,
    conv1d111: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule30 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization178 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d106 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d107 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d108 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization179 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear324 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear325 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2316: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization180 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization181 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear326 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear327 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2317: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization182 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear328 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear329 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear330 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1288: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1289: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear331 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2331: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear332 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization183 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d109 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d110 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d111 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization178,
            conv1d106,
            conv1d107,
            conv1d108,
            layernormalization179,
            linear324,
            linear325,
            constant2316,
            layernormalization180,
            layernormalization181,
            linear326,
            linear327,
            constant2317,
            layernormalization182,
            linear328,
            linear329,
            linear330,
            constant1288,
            constant1289,
            linear331,
            constant2331,
            linear332,
            layernormalization183,
            conv1d109,
            conv1d110,
            conv1d111,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add214_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization178_out1 = {
            let dtype = add214_out1.clone().dtype();
            self.layernormalization178
                .forward(add214_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose145_out1 = layernormalization178_out1.permute([0, 2, 1]);
        let conv1d106_out1 = self.conv1d106.forward(transpose145_out1);
        let split_tensors = conv1d106_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split36_out1, split36_out2] = split_tensors.try_into().unwrap();
        let sigmoid142_out1 = burn::tensor::activation::sigmoid(split36_out2);
        let mul249_out1 = split36_out1.mul(sigmoid142_out1);
        let conv1d107_out1 = self.conv1d107.forward(mul249_out1);
        let sigmoid143_out1 = burn::tensor::activation::sigmoid(conv1d107_out1.clone());
        let mul250_out1 = conv1d107_out1.mul(sigmoid143_out1);
        let conv1d108_out1 = self.conv1d108.forward(mul250_out1);
        let transpose146_out1 = conv1d108_out1.permute([0, 2, 1]);
        let add215_out1 = add214_out1.add(transpose146_out1);
        let layernormalization179_out1 = {
            let dtype = add215_out1.clone().dtype();
            self.layernormalization179
                .forward(add215_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear324_out1 = self.linear324.forward(layernormalization179_out1);
        let sigmoid144_out1 = burn::tensor::activation::sigmoid(linear324_out1.clone());
        let mul251_out1 = linear324_out1.mul(sigmoid144_out1);
        let linear325_out1 = self.linear325.forward(mul251_out1);
        let constant2316_out1 = self.constant2316.val();
        let mul252_out1 = linear325_out1
            .mul((constant2316_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add216_out1 = add215_out1.add(mul252_out1);
        let layernormalization180_out1 = {
            let dtype = add216_out1.dtype();
            self.layernormalization180
                .forward(add216_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization181_out1 = {
            let dtype = layernormalization180_out1.clone().dtype();
            self.layernormalization181
                .forward(
                    layernormalization180_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear326_out1 = self.linear326.forward(layernormalization181_out1);
        let sigmoid145_out1 = burn::tensor::activation::sigmoid(linear326_out1.clone());
        let mul253_out1 = linear326_out1.mul(sigmoid145_out1);
        let linear327_out1 = self.linear327.forward(mul253_out1);
        let constant2317_out1 = self.constant2317.val();
        let mul254_out1 = linear327_out1
            .mul((constant2317_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add217_out1 = layernormalization180_out1.add(mul254_out1);
        let layernormalization182_out1 = {
            let dtype = add217_out1.clone().dtype();
            self.layernormalization182
                .forward(add217_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear328_out1 = self.linear328.forward(layernormalization182_out1.clone());
        let linear329_out1 = self.linear329.forward(layernormalization182_out1.clone());
        let linear330_out1 = self.linear330.forward(layernormalization182_out1);
        let constant1288_out1 = self.constant1288.val();
        let add218_out1 = linear328_out1
            .clone()
            .add((constant1288_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape147_out1 = linear328_out1.reshape([0, -1, 8, 160]);
        let transpose147_out1 = reshape147_out1.permute([0, 2, 1, 3]);
        let constant1289_out1 = self.constant1289.val();
        let add219_out1 = transpose147_out1.clone().add(constant1289_out1);
        let linear331_out1 = self.linear331.forward(reshape2_out1);
        let reshape148_out1 = linear331_out1.reshape([0, -1, 8, 160]);
        let transpose148_out1 = reshape148_out1.permute([0, 2, 3, 1]);
        let matmul369_out1 = add219_out1.matmul(transpose148_out1);
        let pad37_out1 = matmul369_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape38_out1: [i64; 4] = {
            let axes = &transpose147_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather38_out1 = shape38_out1[2] as i64;
        let unsqueeze41_out1 = [gather38_out1 as i64];
        let constant2323_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat74_out1: [i64; 4usize] = [
            &constant2323_out1[..],
            &unsqueeze41_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape149_out1 = pad37_out1.reshape(concat74_out1);
        let slice73_out1 = reshape149_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2327_out1: [i64; 2] = [0i64, 0i64];
        let constant2328_out1: [i64; 1] = [-1i64];
        let concat75_out1: [i64; 4usize] = [
            &constant2327_out1[..],
            &unsqueeze41_out1[..],
            &constant2328_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape150_out1 = slice73_out1.reshape(concat75_out1);
        let slice74_out1 = reshape150_out1.slice(s![.., .., .., 0..unsqueeze41_out1[0]]);
        let constant2331_out1 = self.constant2331.val();
        let mul255_out1 = slice74_out1
            .mul((constant2331_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention37_out1,) = {
            let q = add218_out1;
            let k = linear329_out1;
            let v = linear330_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul255_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention37_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention37_out1 = {
                let dims = attention37_out1.dims();
                attention37_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention37_out1 = attention37_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention37_out1,)
        };
        let linear332_out1 = self.linear332.forward(attention37_out1);
        let add220_out1 = add217_out1.add(linear332_out1);
        let layernormalization183_out1 = {
            let dtype = add220_out1.clone().dtype();
            self.layernormalization183
                .forward(add220_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose149_out1 = layernormalization183_out1.permute([0, 2, 1]);
        let conv1d109_out1 = self.conv1d109.forward(transpose149_out1);
        let split_tensors = conv1d109_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split37_out1, split37_out2] = split_tensors.try_into().unwrap();
        let sigmoid146_out1 = burn::tensor::activation::sigmoid(split37_out2);
        let mul256_out1 = split37_out1.mul(sigmoid146_out1);
        let conv1d110_out1 = self.conv1d110.forward(mul256_out1);
        let sigmoid147_out1 = burn::tensor::activation::sigmoid(conv1d110_out1.clone());
        let mul257_out1 = conv1d110_out1.mul(sigmoid147_out1);
        let conv1d111_out1 = self.conv1d111.forward(mul257_out1);
        let transpose150_out1 = conv1d111_out1.permute([0, 2, 1]);
        let add221_out1 = add220_out1.add(transpose150_out1);
        add221_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule31 {
    layernormalization184: LayerNorm,
    linear333: Linear,
    linear334: Linear,
    constant2333: burn::module::Param<Tensor<1>>,
    layernormalization185: LayerNorm,
    layernormalization186: LayerNorm,
    linear335: Linear,
    linear336: Linear,
    constant2334: burn::module::Param<Tensor<1>>,
    layernormalization187: LayerNorm,
    linear337: Linear,
    linear338: Linear,
    linear339: Linear,
    constant1323: burn::module::Param<Tensor<1>>,
    constant1324: burn::module::Param<Tensor<4>>,
    linear340: Linear,
    constant2348: burn::module::Param<Tensor<1>>,
    linear341: Linear,
    layernormalization188: LayerNorm,
    conv1d112: Conv1d,
    conv1d113: Conv1d,
    conv1d114: Conv1d,
    layernormalization189: LayerNorm,
    linear342: Linear,
    linear343: Linear,
    constant2350: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule31 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization184 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear333 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear334 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2333: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization185 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization186 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear335 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear336 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2334: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization187 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear337 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear338 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear339 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1323: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1324: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear340 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2348: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear341 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization188 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d112 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d113 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d114 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization189 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear342 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear343 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2350: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization184,
            linear333,
            linear334,
            constant2333,
            layernormalization185,
            layernormalization186,
            linear335,
            linear336,
            constant2334,
            layernormalization187,
            linear337,
            linear338,
            linear339,
            constant1323,
            constant1324,
            linear340,
            constant2348,
            linear341,
            layernormalization188,
            conv1d112,
            conv1d113,
            conv1d114,
            layernormalization189,
            linear342,
            linear343,
            constant2350,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add221_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization184_out1 = {
            let dtype = add221_out1.clone().dtype();
            self.layernormalization184
                .forward(add221_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear333_out1 = self.linear333.forward(layernormalization184_out1);
        let sigmoid148_out1 = burn::tensor::activation::sigmoid(linear333_out1.clone());
        let mul258_out1 = linear333_out1.mul(sigmoid148_out1);
        let linear334_out1 = self.linear334.forward(mul258_out1);
        let constant2333_out1 = self.constant2333.val();
        let mul259_out1 = linear334_out1
            .mul((constant2333_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add222_out1 = add221_out1.add(mul259_out1);
        let layernormalization185_out1 = {
            let dtype = add222_out1.dtype();
            self.layernormalization185
                .forward(add222_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization186_out1 = {
            let dtype = layernormalization185_out1.clone().dtype();
            self.layernormalization186
                .forward(
                    layernormalization185_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear335_out1 = self.linear335.forward(layernormalization186_out1);
        let sigmoid149_out1 = burn::tensor::activation::sigmoid(linear335_out1.clone());
        let mul260_out1 = linear335_out1.mul(sigmoid149_out1);
        let linear336_out1 = self.linear336.forward(mul260_out1);
        let constant2334_out1 = self.constant2334.val();
        let mul261_out1 = linear336_out1
            .mul((constant2334_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add223_out1 = layernormalization185_out1.add(mul261_out1);
        let layernormalization187_out1 = {
            let dtype = add223_out1.clone().dtype();
            self.layernormalization187
                .forward(add223_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear337_out1 = self.linear337.forward(layernormalization187_out1.clone());
        let linear338_out1 = self.linear338.forward(layernormalization187_out1.clone());
        let linear339_out1 = self.linear339.forward(layernormalization187_out1);
        let constant1323_out1 = self.constant1323.val();
        let add224_out1 = linear337_out1
            .clone()
            .add((constant1323_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape151_out1 = linear337_out1.reshape([0, -1, 8, 160]);
        let transpose151_out1 = reshape151_out1.permute([0, 2, 1, 3]);
        let constant1324_out1 = self.constant1324.val();
        let add225_out1 = transpose151_out1.clone().add(constant1324_out1);
        let linear340_out1 = self.linear340.forward(reshape2_out1);
        let reshape152_out1 = linear340_out1.reshape([0, -1, 8, 160]);
        let transpose152_out1 = reshape152_out1.permute([0, 2, 3, 1]);
        let matmul379_out1 = add225_out1.matmul(transpose152_out1);
        let pad38_out1 = matmul379_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape39_out1: [i64; 4] = {
            let axes = &transpose151_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather39_out1 = shape39_out1[2] as i64;
        let unsqueeze42_out1 = [gather39_out1 as i64];
        let constant2340_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat76_out1: [i64; 4usize] = [
            &constant2340_out1[..],
            &unsqueeze42_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape153_out1 = pad38_out1.reshape(concat76_out1);
        let slice75_out1 = reshape153_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2344_out1: [i64; 2] = [0i64, 0i64];
        let constant2345_out1: [i64; 1] = [-1i64];
        let concat77_out1: [i64; 4usize] = [
            &constant2344_out1[..],
            &unsqueeze42_out1[..],
            &constant2345_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape154_out1 = slice75_out1.reshape(concat77_out1);
        let slice76_out1 = reshape154_out1.slice(s![.., .., .., 0..unsqueeze42_out1[0]]);
        let constant2348_out1 = self.constant2348.val();
        let mul262_out1 = slice76_out1
            .mul((constant2348_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention38_out1,) = {
            let q = add224_out1;
            let k = linear338_out1;
            let v = linear339_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul262_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention38_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention38_out1 = {
                let dims = attention38_out1.dims();
                attention38_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention38_out1 = attention38_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention38_out1,)
        };
        let linear341_out1 = self.linear341.forward(attention38_out1);
        let add226_out1 = add223_out1.add(linear341_out1);
        let layernormalization188_out1 = {
            let dtype = add226_out1.clone().dtype();
            self.layernormalization188
                .forward(add226_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose153_out1 = layernormalization188_out1.permute([0, 2, 1]);
        let conv1d112_out1 = self.conv1d112.forward(transpose153_out1);
        let split_tensors = conv1d112_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split38_out1, split38_out2] = split_tensors.try_into().unwrap();
        let sigmoid150_out1 = burn::tensor::activation::sigmoid(split38_out2);
        let mul263_out1 = split38_out1.mul(sigmoid150_out1);
        let conv1d113_out1 = self.conv1d113.forward(mul263_out1);
        let sigmoid151_out1 = burn::tensor::activation::sigmoid(conv1d113_out1.clone());
        let mul264_out1 = conv1d113_out1.mul(sigmoid151_out1);
        let conv1d114_out1 = self.conv1d114.forward(mul264_out1);
        let transpose154_out1 = conv1d114_out1.permute([0, 2, 1]);
        let add227_out1 = add226_out1.add(transpose154_out1);
        let layernormalization189_out1 = {
            let dtype = add227_out1.clone().dtype();
            self.layernormalization189
                .forward(add227_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear342_out1 = self.linear342.forward(layernormalization189_out1);
        let sigmoid152_out1 = burn::tensor::activation::sigmoid(linear342_out1.clone());
        let mul265_out1 = linear342_out1.mul(sigmoid152_out1);
        let linear343_out1 = self.linear343.forward(mul265_out1);
        let constant2350_out1 = self.constant2350.val();
        let mul266_out1 = linear343_out1
            .mul((constant2350_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add228_out1 = add227_out1.add(mul266_out1);
        add228_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule32 {
    layernormalization190: LayerNorm,
    layernormalization191: LayerNorm,
    linear344: Linear,
    linear345: Linear,
    constant2351: burn::module::Param<Tensor<1>>,
    layernormalization192: LayerNorm,
    linear346: Linear,
    linear347: Linear,
    linear348: Linear,
    constant1358: burn::module::Param<Tensor<1>>,
    constant1359: burn::module::Param<Tensor<4>>,
    linear349: Linear,
    constant2365: burn::module::Param<Tensor<1>>,
    linear350: Linear,
    layernormalization193: LayerNorm,
    conv1d115: Conv1d,
    conv1d116: Conv1d,
    conv1d117: Conv1d,
    layernormalization194: LayerNorm,
    linear351: Linear,
    linear352: Linear,
    constant2367: burn::module::Param<Tensor<1>>,
    layernormalization195: LayerNorm,
    layernormalization196: LayerNorm,
    linear353: Linear,
    linear354: Linear,
    constant2368: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule32 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization190 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization191 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear344 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear345 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2351: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization192 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear346 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear347 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear348 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1358: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1359: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear349 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2365: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear350 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization193 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d115 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d116 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d117 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization194 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear351 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear352 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2367: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization195 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization196 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear353 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear354 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2368: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization190,
            layernormalization191,
            linear344,
            linear345,
            constant2351,
            layernormalization192,
            linear346,
            linear347,
            linear348,
            constant1358,
            constant1359,
            linear349,
            constant2365,
            linear350,
            layernormalization193,
            conv1d115,
            conv1d116,
            conv1d117,
            layernormalization194,
            linear351,
            linear352,
            constant2367,
            layernormalization195,
            layernormalization196,
            linear353,
            linear354,
            constant2368,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add228_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization190_out1 = {
            let dtype = add228_out1.dtype();
            self.layernormalization190
                .forward(add228_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization191_out1 = {
            let dtype = layernormalization190_out1.clone().dtype();
            self.layernormalization191
                .forward(
                    layernormalization190_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear344_out1 = self.linear344.forward(layernormalization191_out1);
        let sigmoid153_out1 = burn::tensor::activation::sigmoid(linear344_out1.clone());
        let mul267_out1 = linear344_out1.mul(sigmoid153_out1);
        let linear345_out1 = self.linear345.forward(mul267_out1);
        let constant2351_out1 = self.constant2351.val();
        let mul268_out1 = linear345_out1
            .mul((constant2351_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add229_out1 = layernormalization190_out1.add(mul268_out1);
        let layernormalization192_out1 = {
            let dtype = add229_out1.clone().dtype();
            self.layernormalization192
                .forward(add229_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear346_out1 = self.linear346.forward(layernormalization192_out1.clone());
        let linear347_out1 = self.linear347.forward(layernormalization192_out1.clone());
        let linear348_out1 = self.linear348.forward(layernormalization192_out1);
        let constant1358_out1 = self.constant1358.val();
        let add230_out1 = linear346_out1
            .clone()
            .add((constant1358_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape155_out1 = linear346_out1.reshape([0, -1, 8, 160]);
        let transpose155_out1 = reshape155_out1.permute([0, 2, 1, 3]);
        let constant1359_out1 = self.constant1359.val();
        let add231_out1 = transpose155_out1.clone().add(constant1359_out1);
        let linear349_out1 = self.linear349.forward(reshape2_out1);
        let reshape156_out1 = linear349_out1.reshape([0, -1, 8, 160]);
        let transpose156_out1 = reshape156_out1.permute([0, 2, 3, 1]);
        let matmul389_out1 = add231_out1.matmul(transpose156_out1);
        let pad39_out1 = matmul389_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape40_out1: [i64; 4] = {
            let axes = &transpose155_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather40_out1 = shape40_out1[2] as i64;
        let unsqueeze43_out1 = [gather40_out1 as i64];
        let constant2357_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat78_out1: [i64; 4usize] = [
            &constant2357_out1[..],
            &unsqueeze43_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape157_out1 = pad39_out1.reshape(concat78_out1);
        let slice77_out1 = reshape157_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2361_out1: [i64; 2] = [0i64, 0i64];
        let constant2362_out1: [i64; 1] = [-1i64];
        let concat79_out1: [i64; 4usize] = [
            &constant2361_out1[..],
            &unsqueeze43_out1[..],
            &constant2362_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape158_out1 = slice77_out1.reshape(concat79_out1);
        let slice78_out1 = reshape158_out1.slice(s![.., .., .., 0..unsqueeze43_out1[0]]);
        let constant2365_out1 = self.constant2365.val();
        let mul269_out1 = slice78_out1
            .mul((constant2365_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention39_out1,) = {
            let q = add230_out1;
            let k = linear347_out1;
            let v = linear348_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul269_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention39_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention39_out1 = {
                let dims = attention39_out1.dims();
                attention39_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention39_out1 = attention39_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention39_out1,)
        };
        let linear350_out1 = self.linear350.forward(attention39_out1);
        let add232_out1 = add229_out1.add(linear350_out1);
        let layernormalization193_out1 = {
            let dtype = add232_out1.clone().dtype();
            self.layernormalization193
                .forward(add232_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose157_out1 = layernormalization193_out1.permute([0, 2, 1]);
        let conv1d115_out1 = self.conv1d115.forward(transpose157_out1);
        let split_tensors = conv1d115_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split39_out1, split39_out2] = split_tensors.try_into().unwrap();
        let sigmoid154_out1 = burn::tensor::activation::sigmoid(split39_out2);
        let mul270_out1 = split39_out1.mul(sigmoid154_out1);
        let conv1d116_out1 = self.conv1d116.forward(mul270_out1);
        let sigmoid155_out1 = burn::tensor::activation::sigmoid(conv1d116_out1.clone());
        let mul271_out1 = conv1d116_out1.mul(sigmoid155_out1);
        let conv1d117_out1 = self.conv1d117.forward(mul271_out1);
        let transpose158_out1 = conv1d117_out1.permute([0, 2, 1]);
        let add233_out1 = add232_out1.add(transpose158_out1);
        let layernormalization194_out1 = {
            let dtype = add233_out1.clone().dtype();
            self.layernormalization194
                .forward(add233_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear351_out1 = self.linear351.forward(layernormalization194_out1);
        let sigmoid156_out1 = burn::tensor::activation::sigmoid(linear351_out1.clone());
        let mul272_out1 = linear351_out1.mul(sigmoid156_out1);
        let linear352_out1 = self.linear352.forward(mul272_out1);
        let constant2367_out1 = self.constant2367.val();
        let mul273_out1 = linear352_out1
            .mul((constant2367_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add234_out1 = add233_out1.add(mul273_out1);
        let layernormalization195_out1 = {
            let dtype = add234_out1.dtype();
            self.layernormalization195
                .forward(add234_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization196_out1 = {
            let dtype = layernormalization195_out1.clone().dtype();
            self.layernormalization196
                .forward(
                    layernormalization195_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear353_out1 = self.linear353.forward(layernormalization196_out1);
        let sigmoid157_out1 = burn::tensor::activation::sigmoid(linear353_out1.clone());
        let mul274_out1 = linear353_out1.mul(sigmoid157_out1);
        let linear354_out1 = self.linear354.forward(mul274_out1);
        let constant2368_out1 = self.constant2368.val();
        let mul275_out1 = linear354_out1
            .mul((constant2368_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add235_out1 = layernormalization195_out1.add(mul275_out1);
        add235_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule33 {
    layernormalization197: LayerNorm,
    linear355: Linear,
    linear356: Linear,
    linear357: Linear,
    constant1393: burn::module::Param<Tensor<1>>,
    constant1394: burn::module::Param<Tensor<4>>,
    linear358: Linear,
    constant2382: burn::module::Param<Tensor<1>>,
    linear359: Linear,
    layernormalization198: LayerNorm,
    conv1d118: Conv1d,
    conv1d119: Conv1d,
    conv1d120: Conv1d,
    layernormalization199: LayerNorm,
    linear360: Linear,
    linear361: Linear,
    constant2384: burn::module::Param<Tensor<1>>,
    layernormalization200: LayerNorm,
    layernormalization201: LayerNorm,
    linear362: Linear,
    linear363: Linear,
    constant2385: burn::module::Param<Tensor<1>>,
    layernormalization202: LayerNorm,
    linear364: Linear,
    linear365: Linear,
    linear366: Linear,
    constant1428: burn::module::Param<Tensor<1>>,
    constant1429: burn::module::Param<Tensor<4>>,
    linear367: Linear,
    constant2399: burn::module::Param<Tensor<1>>,
    linear368: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule33 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization197 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear355 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear356 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear357 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1393: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1394: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear358 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2382: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear359 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization198 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d118 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d119 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d120 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization199 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear360 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear361 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2384: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization200 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization201 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear362 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear363 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2385: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization202 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear364 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear365 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear366 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1428: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1429: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear367 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2399: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear368 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization197,
            linear355,
            linear356,
            linear357,
            constant1393,
            constant1394,
            linear358,
            constant2382,
            linear359,
            layernormalization198,
            conv1d118,
            conv1d119,
            conv1d120,
            layernormalization199,
            linear360,
            linear361,
            constant2384,
            layernormalization200,
            layernormalization201,
            linear362,
            linear363,
            constant2385,
            layernormalization202,
            linear364,
            linear365,
            linear366,
            constant1428,
            constant1429,
            linear367,
            constant2399,
            linear368,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add235_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization197_out1 = {
            let dtype = add235_out1.clone().dtype();
            self.layernormalization197
                .forward(add235_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear355_out1 = self.linear355.forward(layernormalization197_out1.clone());
        let linear356_out1 = self.linear356.forward(layernormalization197_out1.clone());
        let linear357_out1 = self.linear357.forward(layernormalization197_out1);
        let constant1393_out1 = self.constant1393.val();
        let add236_out1 = linear355_out1
            .clone()
            .add((constant1393_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape159_out1 = linear355_out1.reshape([0, -1, 8, 160]);
        let transpose159_out1 = reshape159_out1.permute([0, 2, 1, 3]);
        let constant1394_out1 = self.constant1394.val();
        let add237_out1 = transpose159_out1.clone().add(constant1394_out1);
        let linear358_out1 = self.linear358.forward(reshape2_out1.clone());
        let reshape160_out1 = linear358_out1.reshape([0, -1, 8, 160]);
        let transpose160_out1 = reshape160_out1.permute([0, 2, 3, 1]);
        let matmul399_out1 = add237_out1.matmul(transpose160_out1);
        let pad40_out1 = matmul399_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape41_out1: [i64; 4] = {
            let axes = &transpose159_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather41_out1 = shape41_out1[2] as i64;
        let unsqueeze44_out1 = [gather41_out1 as i64];
        let constant2374_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat80_out1: [i64; 4usize] = [
            &constant2374_out1[..],
            &unsqueeze44_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape161_out1 = pad40_out1.reshape(concat80_out1);
        let slice79_out1 = reshape161_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2378_out1: [i64; 2] = [0i64, 0i64];
        let constant2379_out1: [i64; 1] = [-1i64];
        let concat81_out1: [i64; 4usize] = [
            &constant2378_out1[..],
            &unsqueeze44_out1[..],
            &constant2379_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape162_out1 = slice79_out1.reshape(concat81_out1);
        let slice80_out1 = reshape162_out1.slice(s![.., .., .., 0..unsqueeze44_out1[0]]);
        let constant2382_out1 = self.constant2382.val();
        let mul276_out1 = slice80_out1
            .mul((constant2382_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention40_out1,) = {
            let q = add236_out1;
            let k = linear356_out1;
            let v = linear357_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul276_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention40_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention40_out1 = {
                let dims = attention40_out1.dims();
                attention40_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention40_out1 = attention40_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention40_out1,)
        };
        let linear359_out1 = self.linear359.forward(attention40_out1);
        let add238_out1 = add235_out1.add(linear359_out1);
        let layernormalization198_out1 = {
            let dtype = add238_out1.clone().dtype();
            self.layernormalization198
                .forward(add238_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose161_out1 = layernormalization198_out1.permute([0, 2, 1]);
        let conv1d118_out1 = self.conv1d118.forward(transpose161_out1);
        let split_tensors = conv1d118_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split40_out1, split40_out2] = split_tensors.try_into().unwrap();
        let sigmoid158_out1 = burn::tensor::activation::sigmoid(split40_out2);
        let mul277_out1 = split40_out1.mul(sigmoid158_out1);
        let conv1d119_out1 = self.conv1d119.forward(mul277_out1);
        let sigmoid159_out1 = burn::tensor::activation::sigmoid(conv1d119_out1.clone());
        let mul278_out1 = conv1d119_out1.mul(sigmoid159_out1);
        let conv1d120_out1 = self.conv1d120.forward(mul278_out1);
        let transpose162_out1 = conv1d120_out1.permute([0, 2, 1]);
        let add239_out1 = add238_out1.add(transpose162_out1);
        let layernormalization199_out1 = {
            let dtype = add239_out1.clone().dtype();
            self.layernormalization199
                .forward(add239_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear360_out1 = self.linear360.forward(layernormalization199_out1);
        let sigmoid160_out1 = burn::tensor::activation::sigmoid(linear360_out1.clone());
        let mul279_out1 = linear360_out1.mul(sigmoid160_out1);
        let linear361_out1 = self.linear361.forward(mul279_out1);
        let constant2384_out1 = self.constant2384.val();
        let mul280_out1 = linear361_out1
            .mul((constant2384_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add240_out1 = add239_out1.add(mul280_out1);
        let layernormalization200_out1 = {
            let dtype = add240_out1.dtype();
            self.layernormalization200
                .forward(add240_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization201_out1 = {
            let dtype = layernormalization200_out1.clone().dtype();
            self.layernormalization201
                .forward(
                    layernormalization200_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear362_out1 = self.linear362.forward(layernormalization201_out1);
        let sigmoid161_out1 = burn::tensor::activation::sigmoid(linear362_out1.clone());
        let mul281_out1 = linear362_out1.mul(sigmoid161_out1);
        let linear363_out1 = self.linear363.forward(mul281_out1);
        let constant2385_out1 = self.constant2385.val();
        let mul282_out1 = linear363_out1
            .mul((constant2385_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add241_out1 = layernormalization200_out1.add(mul282_out1);
        let layernormalization202_out1 = {
            let dtype = add241_out1.clone().dtype();
            self.layernormalization202
                .forward(add241_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear364_out1 = self.linear364.forward(layernormalization202_out1.clone());
        let linear365_out1 = self.linear365.forward(layernormalization202_out1.clone());
        let linear366_out1 = self.linear366.forward(layernormalization202_out1);
        let constant1428_out1 = self.constant1428.val();
        let add242_out1 = linear364_out1
            .clone()
            .add((constant1428_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape163_out1 = linear364_out1.reshape([0, -1, 8, 160]);
        let transpose163_out1 = reshape163_out1.permute([0, 2, 1, 3]);
        let constant1429_out1 = self.constant1429.val();
        let add243_out1 = transpose163_out1.clone().add(constant1429_out1);
        let linear367_out1 = self.linear367.forward(reshape2_out1);
        let reshape164_out1 = linear367_out1.reshape([0, -1, 8, 160]);
        let transpose164_out1 = reshape164_out1.permute([0, 2, 3, 1]);
        let matmul409_out1 = add243_out1.matmul(transpose164_out1);
        let pad41_out1 = matmul409_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape42_out1: [i64; 4] = {
            let axes = &transpose163_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather42_out1 = shape42_out1[2] as i64;
        let unsqueeze45_out1 = [gather42_out1 as i64];
        let constant2391_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat82_out1: [i64; 4usize] = [
            &constant2391_out1[..],
            &unsqueeze45_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape165_out1 = pad41_out1.reshape(concat82_out1);
        let slice81_out1 = reshape165_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2395_out1: [i64; 2] = [0i64, 0i64];
        let constant2396_out1: [i64; 1] = [-1i64];
        let concat83_out1: [i64; 4usize] = [
            &constant2395_out1[..],
            &unsqueeze45_out1[..],
            &constant2396_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape166_out1 = slice81_out1.reshape(concat83_out1);
        let slice82_out1 = reshape166_out1.slice(s![.., .., .., 0..unsqueeze45_out1[0]]);
        let constant2399_out1 = self.constant2399.val();
        let mul283_out1 = slice82_out1
            .mul((constant2399_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention41_out1,) = {
            let q = add242_out1;
            let k = linear365_out1;
            let v = linear366_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul283_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention41_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention41_out1 = {
                let dims = attention41_out1.dims();
                attention41_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention41_out1 = attention41_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention41_out1,)
        };
        let linear368_out1 = self.linear368.forward(attention41_out1);
        let add244_out1 = add241_out1.add(linear368_out1);
        add244_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule34 {
    layernormalization203: LayerNorm,
    conv1d121: Conv1d,
    conv1d122: Conv1d,
    conv1d123: Conv1d,
    layernormalization204: LayerNorm,
    linear369: Linear,
    linear370: Linear,
    constant2401: burn::module::Param<Tensor<1>>,
    layernormalization205: LayerNorm,
    layernormalization206: LayerNorm,
    linear371: Linear,
    linear372: Linear,
    constant2402: burn::module::Param<Tensor<1>>,
    layernormalization207: LayerNorm,
    linear373: Linear,
    linear374: Linear,
    linear375: Linear,
    constant1463: burn::module::Param<Tensor<1>>,
    constant1464: burn::module::Param<Tensor<4>>,
    linear376: Linear,
    constant2416: burn::module::Param<Tensor<1>>,
    linear377: Linear,
    layernormalization208: LayerNorm,
    conv1d124: Conv1d,
    conv1d125: Conv1d,
    conv1d126: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule34 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization203 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d121 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d122 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d123 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization204 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear369 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear370 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2401: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization205 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization206 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear371 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear372 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2402: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization207 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear373 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear374 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear375 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1463: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1464: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear376 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2416: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear377 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization208 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d124 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d125 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d126 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization203,
            conv1d121,
            conv1d122,
            conv1d123,
            layernormalization204,
            linear369,
            linear370,
            constant2401,
            layernormalization205,
            layernormalization206,
            linear371,
            linear372,
            constant2402,
            layernormalization207,
            linear373,
            linear374,
            linear375,
            constant1463,
            constant1464,
            linear376,
            constant2416,
            linear377,
            layernormalization208,
            conv1d124,
            conv1d125,
            conv1d126,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add244_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization203_out1 = {
            let dtype = add244_out1.clone().dtype();
            self.layernormalization203
                .forward(add244_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose165_out1 = layernormalization203_out1.permute([0, 2, 1]);
        let conv1d121_out1 = self.conv1d121.forward(transpose165_out1);
        let split_tensors = conv1d121_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split41_out1, split41_out2] = split_tensors.try_into().unwrap();
        let sigmoid162_out1 = burn::tensor::activation::sigmoid(split41_out2);
        let mul284_out1 = split41_out1.mul(sigmoid162_out1);
        let conv1d122_out1 = self.conv1d122.forward(mul284_out1);
        let sigmoid163_out1 = burn::tensor::activation::sigmoid(conv1d122_out1.clone());
        let mul285_out1 = conv1d122_out1.mul(sigmoid163_out1);
        let conv1d123_out1 = self.conv1d123.forward(mul285_out1);
        let transpose166_out1 = conv1d123_out1.permute([0, 2, 1]);
        let add245_out1 = add244_out1.add(transpose166_out1);
        let layernormalization204_out1 = {
            let dtype = add245_out1.clone().dtype();
            self.layernormalization204
                .forward(add245_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear369_out1 = self.linear369.forward(layernormalization204_out1);
        let sigmoid164_out1 = burn::tensor::activation::sigmoid(linear369_out1.clone());
        let mul286_out1 = linear369_out1.mul(sigmoid164_out1);
        let linear370_out1 = self.linear370.forward(mul286_out1);
        let constant2401_out1 = self.constant2401.val();
        let mul287_out1 = linear370_out1
            .mul((constant2401_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add246_out1 = add245_out1.add(mul287_out1);
        let layernormalization205_out1 = {
            let dtype = add246_out1.dtype();
            self.layernormalization205
                .forward(add246_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization206_out1 = {
            let dtype = layernormalization205_out1.clone().dtype();
            self.layernormalization206
                .forward(
                    layernormalization205_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear371_out1 = self.linear371.forward(layernormalization206_out1);
        let sigmoid165_out1 = burn::tensor::activation::sigmoid(linear371_out1.clone());
        let mul288_out1 = linear371_out1.mul(sigmoid165_out1);
        let linear372_out1 = self.linear372.forward(mul288_out1);
        let constant2402_out1 = self.constant2402.val();
        let mul289_out1 = linear372_out1
            .mul((constant2402_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add247_out1 = layernormalization205_out1.add(mul289_out1);
        let layernormalization207_out1 = {
            let dtype = add247_out1.clone().dtype();
            self.layernormalization207
                .forward(add247_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear373_out1 = self.linear373.forward(layernormalization207_out1.clone());
        let linear374_out1 = self.linear374.forward(layernormalization207_out1.clone());
        let linear375_out1 = self.linear375.forward(layernormalization207_out1);
        let constant1463_out1 = self.constant1463.val();
        let add248_out1 = linear373_out1
            .clone()
            .add((constant1463_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape167_out1 = linear373_out1.reshape([0, -1, 8, 160]);
        let transpose167_out1 = reshape167_out1.permute([0, 2, 1, 3]);
        let constant1464_out1 = self.constant1464.val();
        let add249_out1 = transpose167_out1.clone().add(constant1464_out1);
        let linear376_out1 = self.linear376.forward(reshape2_out1);
        let reshape168_out1 = linear376_out1.reshape([0, -1, 8, 160]);
        let transpose168_out1 = reshape168_out1.permute([0, 2, 3, 1]);
        let matmul419_out1 = add249_out1.matmul(transpose168_out1);
        let pad42_out1 = matmul419_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape43_out1: [i64; 4] = {
            let axes = &transpose167_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather43_out1 = shape43_out1[2] as i64;
        let unsqueeze46_out1 = [gather43_out1 as i64];
        let constant2408_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat84_out1: [i64; 4usize] = [
            &constant2408_out1[..],
            &unsqueeze46_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape169_out1 = pad42_out1.reshape(concat84_out1);
        let slice83_out1 = reshape169_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2412_out1: [i64; 2] = [0i64, 0i64];
        let constant2413_out1: [i64; 1] = [-1i64];
        let concat85_out1: [i64; 4usize] = [
            &constant2412_out1[..],
            &unsqueeze46_out1[..],
            &constant2413_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape170_out1 = slice83_out1.reshape(concat85_out1);
        let slice84_out1 = reshape170_out1.slice(s![.., .., .., 0..unsqueeze46_out1[0]]);
        let constant2416_out1 = self.constant2416.val();
        let mul290_out1 = slice84_out1
            .mul((constant2416_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention42_out1,) = {
            let q = add248_out1;
            let k = linear374_out1;
            let v = linear375_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul290_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention42_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention42_out1 = {
                let dims = attention42_out1.dims();
                attention42_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention42_out1 = attention42_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention42_out1,)
        };
        let linear377_out1 = self.linear377.forward(attention42_out1);
        let add250_out1 = add247_out1.add(linear377_out1);
        let layernormalization208_out1 = {
            let dtype = add250_out1.clone().dtype();
            self.layernormalization208
                .forward(add250_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose169_out1 = layernormalization208_out1.permute([0, 2, 1]);
        let conv1d124_out1 = self.conv1d124.forward(transpose169_out1);
        let split_tensors = conv1d124_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split42_out1, split42_out2] = split_tensors.try_into().unwrap();
        let sigmoid166_out1 = burn::tensor::activation::sigmoid(split42_out2);
        let mul291_out1 = split42_out1.mul(sigmoid166_out1);
        let conv1d125_out1 = self.conv1d125.forward(mul291_out1);
        let sigmoid167_out1 = burn::tensor::activation::sigmoid(conv1d125_out1.clone());
        let mul292_out1 = conv1d125_out1.mul(sigmoid167_out1);
        let conv1d126_out1 = self.conv1d126.forward(mul292_out1);
        let transpose170_out1 = conv1d126_out1.permute([0, 2, 1]);
        let add251_out1 = add250_out1.add(transpose170_out1);
        add251_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule35 {
    layernormalization209: LayerNorm,
    linear378: Linear,
    linear379: Linear,
    constant2418: burn::module::Param<Tensor<1>>,
    layernormalization210: LayerNorm,
    layernormalization211: LayerNorm,
    linear380: Linear,
    linear381: Linear,
    constant2419: burn::module::Param<Tensor<1>>,
    layernormalization212: LayerNorm,
    linear382: Linear,
    linear383: Linear,
    linear384: Linear,
    constant1498: burn::module::Param<Tensor<1>>,
    constant1499: burn::module::Param<Tensor<4>>,
    linear385: Linear,
    constant2433: burn::module::Param<Tensor<1>>,
    linear386: Linear,
    layernormalization213: LayerNorm,
    conv1d127: Conv1d,
    conv1d128: Conv1d,
    conv1d129: Conv1d,
    layernormalization214: LayerNorm,
    linear387: Linear,
    linear388: Linear,
    constant2435: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule35 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization209 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear378 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear379 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2418: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization210 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization211 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear380 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear381 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2419: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization212 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear382 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear383 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear384 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1498: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1499: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear385 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2433: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear386 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization213 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d127 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d128 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d129 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization214 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear387 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear388 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2435: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization209,
            linear378,
            linear379,
            constant2418,
            layernormalization210,
            layernormalization211,
            linear380,
            linear381,
            constant2419,
            layernormalization212,
            linear382,
            linear383,
            linear384,
            constant1498,
            constant1499,
            linear385,
            constant2433,
            linear386,
            layernormalization213,
            conv1d127,
            conv1d128,
            conv1d129,
            layernormalization214,
            linear387,
            linear388,
            constant2435,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add251_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization209_out1 = {
            let dtype = add251_out1.clone().dtype();
            self.layernormalization209
                .forward(add251_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear378_out1 = self.linear378.forward(layernormalization209_out1);
        let sigmoid168_out1 = burn::tensor::activation::sigmoid(linear378_out1.clone());
        let mul293_out1 = linear378_out1.mul(sigmoid168_out1);
        let linear379_out1 = self.linear379.forward(mul293_out1);
        let constant2418_out1 = self.constant2418.val();
        let mul294_out1 = linear379_out1
            .mul((constant2418_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add252_out1 = add251_out1.add(mul294_out1);
        let layernormalization210_out1 = {
            let dtype = add252_out1.dtype();
            self.layernormalization210
                .forward(add252_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization211_out1 = {
            let dtype = layernormalization210_out1.clone().dtype();
            self.layernormalization211
                .forward(
                    layernormalization210_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear380_out1 = self.linear380.forward(layernormalization211_out1);
        let sigmoid169_out1 = burn::tensor::activation::sigmoid(linear380_out1.clone());
        let mul295_out1 = linear380_out1.mul(sigmoid169_out1);
        let linear381_out1 = self.linear381.forward(mul295_out1);
        let constant2419_out1 = self.constant2419.val();
        let mul296_out1 = linear381_out1
            .mul((constant2419_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add253_out1 = layernormalization210_out1.add(mul296_out1);
        let layernormalization212_out1 = {
            let dtype = add253_out1.clone().dtype();
            self.layernormalization212
                .forward(add253_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear382_out1 = self.linear382.forward(layernormalization212_out1.clone());
        let linear383_out1 = self.linear383.forward(layernormalization212_out1.clone());
        let linear384_out1 = self.linear384.forward(layernormalization212_out1);
        let constant1498_out1 = self.constant1498.val();
        let add254_out1 = linear382_out1
            .clone()
            .add((constant1498_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape171_out1 = linear382_out1.reshape([0, -1, 8, 160]);
        let transpose171_out1 = reshape171_out1.permute([0, 2, 1, 3]);
        let constant1499_out1 = self.constant1499.val();
        let add255_out1 = transpose171_out1.clone().add(constant1499_out1);
        let linear385_out1 = self.linear385.forward(reshape2_out1);
        let reshape172_out1 = linear385_out1.reshape([0, -1, 8, 160]);
        let transpose172_out1 = reshape172_out1.permute([0, 2, 3, 1]);
        let matmul429_out1 = add255_out1.matmul(transpose172_out1);
        let pad43_out1 = matmul429_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape44_out1: [i64; 4] = {
            let axes = &transpose171_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather44_out1 = shape44_out1[2] as i64;
        let unsqueeze47_out1 = [gather44_out1 as i64];
        let constant2425_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat86_out1: [i64; 4usize] = [
            &constant2425_out1[..],
            &unsqueeze47_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape173_out1 = pad43_out1.reshape(concat86_out1);
        let slice85_out1 = reshape173_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2429_out1: [i64; 2] = [0i64, 0i64];
        let constant2430_out1: [i64; 1] = [-1i64];
        let concat87_out1: [i64; 4usize] = [
            &constant2429_out1[..],
            &unsqueeze47_out1[..],
            &constant2430_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape174_out1 = slice85_out1.reshape(concat87_out1);
        let slice86_out1 = reshape174_out1.slice(s![.., .., .., 0..unsqueeze47_out1[0]]);
        let constant2433_out1 = self.constant2433.val();
        let mul297_out1 = slice86_out1
            .mul((constant2433_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention43_out1,) = {
            let q = add254_out1;
            let k = linear383_out1;
            let v = linear384_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul297_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention43_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention43_out1 = {
                let dims = attention43_out1.dims();
                attention43_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention43_out1 = attention43_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention43_out1,)
        };
        let linear386_out1 = self.linear386.forward(attention43_out1);
        let add256_out1 = add253_out1.add(linear386_out1);
        let layernormalization213_out1 = {
            let dtype = add256_out1.clone().dtype();
            self.layernormalization213
                .forward(add256_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose173_out1 = layernormalization213_out1.permute([0, 2, 1]);
        let conv1d127_out1 = self.conv1d127.forward(transpose173_out1);
        let split_tensors = conv1d127_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split43_out1, split43_out2] = split_tensors.try_into().unwrap();
        let sigmoid170_out1 = burn::tensor::activation::sigmoid(split43_out2);
        let mul298_out1 = split43_out1.mul(sigmoid170_out1);
        let conv1d128_out1 = self.conv1d128.forward(mul298_out1);
        let sigmoid171_out1 = burn::tensor::activation::sigmoid(conv1d128_out1.clone());
        let mul299_out1 = conv1d128_out1.mul(sigmoid171_out1);
        let conv1d129_out1 = self.conv1d129.forward(mul299_out1);
        let transpose174_out1 = conv1d129_out1.permute([0, 2, 1]);
        let add257_out1 = add256_out1.add(transpose174_out1);
        let layernormalization214_out1 = {
            let dtype = add257_out1.clone().dtype();
            self.layernormalization214
                .forward(add257_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear387_out1 = self.linear387.forward(layernormalization214_out1);
        let sigmoid172_out1 = burn::tensor::activation::sigmoid(linear387_out1.clone());
        let mul300_out1 = linear387_out1.mul(sigmoid172_out1);
        let linear388_out1 = self.linear388.forward(mul300_out1);
        let constant2435_out1 = self.constant2435.val();
        let mul301_out1 = linear388_out1
            .mul((constant2435_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add258_out1 = add257_out1.add(mul301_out1);
        add258_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule36 {
    layernormalization215: LayerNorm,
    layernormalization216: LayerNorm,
    linear389: Linear,
    linear390: Linear,
    constant2436: burn::module::Param<Tensor<1>>,
    layernormalization217: LayerNorm,
    linear391: Linear,
    linear392: Linear,
    linear393: Linear,
    constant1533: burn::module::Param<Tensor<1>>,
    constant1534: burn::module::Param<Tensor<4>>,
    linear394: Linear,
    constant2450: burn::module::Param<Tensor<1>>,
    linear395: Linear,
    layernormalization218: LayerNorm,
    conv1d130: Conv1d,
    conv1d131: Conv1d,
    conv1d132: Conv1d,
    layernormalization219: LayerNorm,
    linear396: Linear,
    linear397: Linear,
    constant2452: burn::module::Param<Tensor<1>>,
    layernormalization220: LayerNorm,
    layernormalization221: LayerNorm,
    linear398: Linear,
    linear399: Linear,
    constant2453: burn::module::Param<Tensor<1>>,
    #[module(skip)]
    device: Device,
}
impl Submodule36 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization215 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization216 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear389 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear390 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2436: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization217 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear391 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear392 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear393 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1533: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1534: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear394 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2450: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear395 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization218 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d130 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d131 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d132 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization219 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear396 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear397 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2452: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization220 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization221 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear398 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear399 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2453: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            layernormalization215,
            layernormalization216,
            linear389,
            linear390,
            constant2436,
            layernormalization217,
            linear391,
            linear392,
            linear393,
            constant1533,
            constant1534,
            linear394,
            constant2450,
            linear395,
            layernormalization218,
            conv1d130,
            conv1d131,
            conv1d132,
            layernormalization219,
            linear396,
            linear397,
            constant2452,
            layernormalization220,
            layernormalization221,
            linear398,
            linear399,
            constant2453,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add258_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization215_out1 = {
            let dtype = add258_out1.dtype();
            self.layernormalization215
                .forward(add258_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization216_out1 = {
            let dtype = layernormalization215_out1.clone().dtype();
            self.layernormalization216
                .forward(
                    layernormalization215_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear389_out1 = self.linear389.forward(layernormalization216_out1);
        let sigmoid173_out1 = burn::tensor::activation::sigmoid(linear389_out1.clone());
        let mul302_out1 = linear389_out1.mul(sigmoid173_out1);
        let linear390_out1 = self.linear390.forward(mul302_out1);
        let constant2436_out1 = self.constant2436.val();
        let mul303_out1 = linear390_out1
            .mul((constant2436_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add259_out1 = layernormalization215_out1.add(mul303_out1);
        let layernormalization217_out1 = {
            let dtype = add259_out1.clone().dtype();
            self.layernormalization217
                .forward(add259_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear391_out1 = self.linear391.forward(layernormalization217_out1.clone());
        let linear392_out1 = self.linear392.forward(layernormalization217_out1.clone());
        let linear393_out1 = self.linear393.forward(layernormalization217_out1);
        let constant1533_out1 = self.constant1533.val();
        let add260_out1 = linear391_out1
            .clone()
            .add((constant1533_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape175_out1 = linear391_out1.reshape([0, -1, 8, 160]);
        let transpose175_out1 = reshape175_out1.permute([0, 2, 1, 3]);
        let constant1534_out1 = self.constant1534.val();
        let add261_out1 = transpose175_out1.clone().add(constant1534_out1);
        let linear394_out1 = self.linear394.forward(reshape2_out1);
        let reshape176_out1 = linear394_out1.reshape([0, -1, 8, 160]);
        let transpose176_out1 = reshape176_out1.permute([0, 2, 3, 1]);
        let matmul439_out1 = add261_out1.matmul(transpose176_out1);
        let pad44_out1 = matmul439_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape45_out1: [i64; 4] = {
            let axes = &transpose175_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather45_out1 = shape45_out1[2] as i64;
        let unsqueeze48_out1 = [gather45_out1 as i64];
        let constant2442_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat88_out1: [i64; 4usize] = [
            &constant2442_out1[..],
            &unsqueeze48_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape177_out1 = pad44_out1.reshape(concat88_out1);
        let slice87_out1 = reshape177_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2446_out1: [i64; 2] = [0i64, 0i64];
        let constant2447_out1: [i64; 1] = [-1i64];
        let concat89_out1: [i64; 4usize] = [
            &constant2446_out1[..],
            &unsqueeze48_out1[..],
            &constant2447_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape178_out1 = slice87_out1.reshape(concat89_out1);
        let slice88_out1 = reshape178_out1.slice(s![.., .., .., 0..unsqueeze48_out1[0]]);
        let constant2450_out1 = self.constant2450.val();
        let mul304_out1 = slice88_out1
            .mul((constant2450_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention44_out1,) = {
            let q = add260_out1;
            let k = linear392_out1;
            let v = linear393_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul304_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention44_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention44_out1 = {
                let dims = attention44_out1.dims();
                attention44_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention44_out1 = attention44_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention44_out1,)
        };
        let linear395_out1 = self.linear395.forward(attention44_out1);
        let add262_out1 = add259_out1.add(linear395_out1);
        let layernormalization218_out1 = {
            let dtype = add262_out1.clone().dtype();
            self.layernormalization218
                .forward(add262_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose177_out1 = layernormalization218_out1.permute([0, 2, 1]);
        let conv1d130_out1 = self.conv1d130.forward(transpose177_out1);
        let split_tensors = conv1d130_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split44_out1, split44_out2] = split_tensors.try_into().unwrap();
        let sigmoid174_out1 = burn::tensor::activation::sigmoid(split44_out2);
        let mul305_out1 = split44_out1.mul(sigmoid174_out1);
        let conv1d131_out1 = self.conv1d131.forward(mul305_out1);
        let sigmoid175_out1 = burn::tensor::activation::sigmoid(conv1d131_out1.clone());
        let mul306_out1 = conv1d131_out1.mul(sigmoid175_out1);
        let conv1d132_out1 = self.conv1d132.forward(mul306_out1);
        let transpose178_out1 = conv1d132_out1.permute([0, 2, 1]);
        let add263_out1 = add262_out1.add(transpose178_out1);
        let layernormalization219_out1 = {
            let dtype = add263_out1.clone().dtype();
            self.layernormalization219
                .forward(add263_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear396_out1 = self.linear396.forward(layernormalization219_out1);
        let sigmoid176_out1 = burn::tensor::activation::sigmoid(linear396_out1.clone());
        let mul307_out1 = linear396_out1.mul(sigmoid176_out1);
        let linear397_out1 = self.linear397.forward(mul307_out1);
        let constant2452_out1 = self.constant2452.val();
        let mul308_out1 = linear397_out1
            .mul((constant2452_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add264_out1 = add263_out1.add(mul308_out1);
        let layernormalization220_out1 = {
            let dtype = add264_out1.dtype();
            self.layernormalization220
                .forward(add264_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization221_out1 = {
            let dtype = layernormalization220_out1.clone().dtype();
            self.layernormalization221
                .forward(
                    layernormalization220_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear398_out1 = self.linear398.forward(layernormalization221_out1);
        let sigmoid177_out1 = burn::tensor::activation::sigmoid(linear398_out1.clone());
        let mul309_out1 = linear398_out1.mul(sigmoid177_out1);
        let linear399_out1 = self.linear399.forward(mul309_out1);
        let constant2453_out1 = self.constant2453.val();
        let mul310_out1 = linear399_out1
            .mul((constant2453_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add265_out1 = layernormalization220_out1.add(mul310_out1);
        add265_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule37 {
    layernormalization222: LayerNorm,
    linear400: Linear,
    linear401: Linear,
    linear402: Linear,
    constant1568: burn::module::Param<Tensor<1>>,
    constant1569: burn::module::Param<Tensor<4>>,
    linear403: Linear,
    constant2467: burn::module::Param<Tensor<1>>,
    linear404: Linear,
    layernormalization223: LayerNorm,
    conv1d133: Conv1d,
    conv1d134: Conv1d,
    conv1d135: Conv1d,
    layernormalization224: LayerNorm,
    linear405: Linear,
    linear406: Linear,
    constant2469: burn::module::Param<Tensor<1>>,
    layernormalization225: LayerNorm,
    layernormalization226: LayerNorm,
    linear407: Linear,
    linear408: Linear,
    constant2470: burn::module::Param<Tensor<1>>,
    layernormalization227: LayerNorm,
    linear409: Linear,
    linear410: Linear,
    linear411: Linear,
    constant1603: burn::module::Param<Tensor<1>>,
    constant1604: burn::module::Param<Tensor<4>>,
    linear412: Linear,
    constant2484: burn::module::Param<Tensor<1>>,
    linear413: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule37 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization222 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear400 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear401 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear402 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1568: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1569: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear403 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2467: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear404 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization223 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d133 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d134 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d135 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization224 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear405 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear406 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2469: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization225 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization226 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear407 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear408 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2470: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization227 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear409 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear410 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear411 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1603: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1604: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear412 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2484: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear413 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        Self {
            layernormalization222,
            linear400,
            linear401,
            linear402,
            constant1568,
            constant1569,
            linear403,
            constant2467,
            linear404,
            layernormalization223,
            conv1d133,
            conv1d134,
            conv1d135,
            layernormalization224,
            linear405,
            linear406,
            constant2469,
            layernormalization225,
            layernormalization226,
            linear407,
            linear408,
            constant2470,
            layernormalization227,
            linear409,
            linear410,
            linear411,
            constant1603,
            constant1604,
            linear412,
            constant2484,
            linear413,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add265_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization222_out1 = {
            let dtype = add265_out1.clone().dtype();
            self.layernormalization222
                .forward(add265_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear400_out1 = self.linear400.forward(layernormalization222_out1.clone());
        let linear401_out1 = self.linear401.forward(layernormalization222_out1.clone());
        let linear402_out1 = self.linear402.forward(layernormalization222_out1);
        let constant1568_out1 = self.constant1568.val();
        let add266_out1 = linear400_out1
            .clone()
            .add((constant1568_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape179_out1 = linear400_out1.reshape([0, -1, 8, 160]);
        let transpose179_out1 = reshape179_out1.permute([0, 2, 1, 3]);
        let constant1569_out1 = self.constant1569.val();
        let add267_out1 = transpose179_out1.clone().add(constant1569_out1);
        let linear403_out1 = self.linear403.forward(reshape2_out1.clone());
        let reshape180_out1 = linear403_out1.reshape([0, -1, 8, 160]);
        let transpose180_out1 = reshape180_out1.permute([0, 2, 3, 1]);
        let matmul449_out1 = add267_out1.matmul(transpose180_out1);
        let pad45_out1 = matmul449_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape46_out1: [i64; 4] = {
            let axes = &transpose179_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather46_out1 = shape46_out1[2] as i64;
        let unsqueeze49_out1 = [gather46_out1 as i64];
        let constant2459_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat90_out1: [i64; 4usize] = [
            &constant2459_out1[..],
            &unsqueeze49_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape181_out1 = pad45_out1.reshape(concat90_out1);
        let slice89_out1 = reshape181_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2463_out1: [i64; 2] = [0i64, 0i64];
        let constant2464_out1: [i64; 1] = [-1i64];
        let concat91_out1: [i64; 4usize] = [
            &constant2463_out1[..],
            &unsqueeze49_out1[..],
            &constant2464_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape182_out1 = slice89_out1.reshape(concat91_out1);
        let slice90_out1 = reshape182_out1.slice(s![.., .., .., 0..unsqueeze49_out1[0]]);
        let constant2467_out1 = self.constant2467.val();
        let mul311_out1 = slice90_out1
            .mul((constant2467_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention45_out1,) = {
            let q = add266_out1;
            let k = linear401_out1;
            let v = linear402_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul311_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention45_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention45_out1 = {
                let dims = attention45_out1.dims();
                attention45_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention45_out1 = attention45_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention45_out1,)
        };
        let linear404_out1 = self.linear404.forward(attention45_out1);
        let add268_out1 = add265_out1.add(linear404_out1);
        let layernormalization223_out1 = {
            let dtype = add268_out1.clone().dtype();
            self.layernormalization223
                .forward(add268_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose181_out1 = layernormalization223_out1.permute([0, 2, 1]);
        let conv1d133_out1 = self.conv1d133.forward(transpose181_out1);
        let split_tensors = conv1d133_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split45_out1, split45_out2] = split_tensors.try_into().unwrap();
        let sigmoid178_out1 = burn::tensor::activation::sigmoid(split45_out2);
        let mul312_out1 = split45_out1.mul(sigmoid178_out1);
        let conv1d134_out1 = self.conv1d134.forward(mul312_out1);
        let sigmoid179_out1 = burn::tensor::activation::sigmoid(conv1d134_out1.clone());
        let mul313_out1 = conv1d134_out1.mul(sigmoid179_out1);
        let conv1d135_out1 = self.conv1d135.forward(mul313_out1);
        let transpose182_out1 = conv1d135_out1.permute([0, 2, 1]);
        let add269_out1 = add268_out1.add(transpose182_out1);
        let layernormalization224_out1 = {
            let dtype = add269_out1.clone().dtype();
            self.layernormalization224
                .forward(add269_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear405_out1 = self.linear405.forward(layernormalization224_out1);
        let sigmoid180_out1 = burn::tensor::activation::sigmoid(linear405_out1.clone());
        let mul314_out1 = linear405_out1.mul(sigmoid180_out1);
        let linear406_out1 = self.linear406.forward(mul314_out1);
        let constant2469_out1 = self.constant2469.val();
        let mul315_out1 = linear406_out1
            .mul((constant2469_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add270_out1 = add269_out1.add(mul315_out1);
        let layernormalization225_out1 = {
            let dtype = add270_out1.dtype();
            self.layernormalization225
                .forward(add270_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization226_out1 = {
            let dtype = layernormalization225_out1.clone().dtype();
            self.layernormalization226
                .forward(
                    layernormalization225_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear407_out1 = self.linear407.forward(layernormalization226_out1);
        let sigmoid181_out1 = burn::tensor::activation::sigmoid(linear407_out1.clone());
        let mul316_out1 = linear407_out1.mul(sigmoid181_out1);
        let linear408_out1 = self.linear408.forward(mul316_out1);
        let constant2470_out1 = self.constant2470.val();
        let mul317_out1 = linear408_out1
            .mul((constant2470_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add271_out1 = layernormalization225_out1.add(mul317_out1);
        let layernormalization227_out1 = {
            let dtype = add271_out1.clone().dtype();
            self.layernormalization227
                .forward(add271_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear409_out1 = self.linear409.forward(layernormalization227_out1.clone());
        let linear410_out1 = self.linear410.forward(layernormalization227_out1.clone());
        let linear411_out1 = self.linear411.forward(layernormalization227_out1);
        let constant1603_out1 = self.constant1603.val();
        let add272_out1 = linear409_out1
            .clone()
            .add((constant1603_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape183_out1 = linear409_out1.reshape([0, -1, 8, 160]);
        let transpose183_out1 = reshape183_out1.permute([0, 2, 1, 3]);
        let constant1604_out1 = self.constant1604.val();
        let add273_out1 = transpose183_out1.clone().add(constant1604_out1);
        let linear412_out1 = self.linear412.forward(reshape2_out1);
        let reshape184_out1 = linear412_out1.reshape([0, -1, 8, 160]);
        let transpose184_out1 = reshape184_out1.permute([0, 2, 3, 1]);
        let matmul459_out1 = add273_out1.matmul(transpose184_out1);
        let pad46_out1 = matmul459_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape47_out1: [i64; 4] = {
            let axes = &transpose183_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather47_out1 = shape47_out1[2] as i64;
        let unsqueeze50_out1 = [gather47_out1 as i64];
        let constant2476_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat92_out1: [i64; 4usize] = [
            &constant2476_out1[..],
            &unsqueeze50_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape185_out1 = pad46_out1.reshape(concat92_out1);
        let slice91_out1 = reshape185_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2480_out1: [i64; 2] = [0i64, 0i64];
        let constant2481_out1: [i64; 1] = [-1i64];
        let concat93_out1: [i64; 4usize] = [
            &constant2480_out1[..],
            &unsqueeze50_out1[..],
            &constant2481_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape186_out1 = slice91_out1.reshape(concat93_out1);
        let slice92_out1 = reshape186_out1.slice(s![.., .., .., 0..unsqueeze50_out1[0]]);
        let constant2484_out1 = self.constant2484.val();
        let mul318_out1 = slice92_out1
            .mul((constant2484_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention46_out1,) = {
            let q = add272_out1;
            let k = linear410_out1;
            let v = linear411_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul318_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention46_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention46_out1 = {
                let dims = attention46_out1.dims();
                attention46_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention46_out1 = attention46_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention46_out1,)
        };
        let linear413_out1 = self.linear413.forward(attention46_out1);
        let add274_out1 = add271_out1.add(linear413_out1);
        add274_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule38 {
    layernormalization228: LayerNorm,
    conv1d136: Conv1d,
    conv1d137: Conv1d,
    conv1d138: Conv1d,
    layernormalization229: LayerNorm,
    linear414: Linear,
    linear415: Linear,
    constant2486: burn::module::Param<Tensor<1>>,
    layernormalization230: LayerNorm,
    layernormalization231: LayerNorm,
    linear416: Linear,
    linear417: Linear,
    constant2487: burn::module::Param<Tensor<1>>,
    layernormalization232: LayerNorm,
    linear418: Linear,
    linear419: Linear,
    linear420: Linear,
    constant1638: burn::module::Param<Tensor<1>>,
    constant1639: burn::module::Param<Tensor<4>>,
    linear421: Linear,
    constant2501: burn::module::Param<Tensor<1>>,
    linear422: Linear,
    layernormalization233: LayerNorm,
    conv1d139: Conv1d,
    conv1d140: Conv1d,
    conv1d141: Conv1d,
    #[module(skip)]
    device: Device,
}
impl Submodule38 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization228 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d136 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d137 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d138 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization229 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear414 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear415 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2486: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization230 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization231 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear416 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear417 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2487: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization232 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear418 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear419 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear420 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1638: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1639: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear421 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2501: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear422 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization233 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d139 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d140 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d141 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization228,
            conv1d136,
            conv1d137,
            conv1d138,
            layernormalization229,
            linear414,
            linear415,
            constant2486,
            layernormalization230,
            layernormalization231,
            linear416,
            linear417,
            constant2487,
            layernormalization232,
            linear418,
            linear419,
            linear420,
            constant1638,
            constant1639,
            linear421,
            constant2501,
            linear422,
            layernormalization233,
            conv1d139,
            conv1d140,
            conv1d141,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add274_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization228_out1 = {
            let dtype = add274_out1.clone().dtype();
            self.layernormalization228
                .forward(add274_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose185_out1 = layernormalization228_out1.permute([0, 2, 1]);
        let conv1d136_out1 = self.conv1d136.forward(transpose185_out1);
        let split_tensors = conv1d136_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split46_out1, split46_out2] = split_tensors.try_into().unwrap();
        let sigmoid182_out1 = burn::tensor::activation::sigmoid(split46_out2);
        let mul319_out1 = split46_out1.mul(sigmoid182_out1);
        let conv1d137_out1 = self.conv1d137.forward(mul319_out1);
        let sigmoid183_out1 = burn::tensor::activation::sigmoid(conv1d137_out1.clone());
        let mul320_out1 = conv1d137_out1.mul(sigmoid183_out1);
        let conv1d138_out1 = self.conv1d138.forward(mul320_out1);
        let transpose186_out1 = conv1d138_out1.permute([0, 2, 1]);
        let add275_out1 = add274_out1.add(transpose186_out1);
        let layernormalization229_out1 = {
            let dtype = add275_out1.clone().dtype();
            self.layernormalization229
                .forward(add275_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear414_out1 = self.linear414.forward(layernormalization229_out1);
        let sigmoid184_out1 = burn::tensor::activation::sigmoid(linear414_out1.clone());
        let mul321_out1 = linear414_out1.mul(sigmoid184_out1);
        let linear415_out1 = self.linear415.forward(mul321_out1);
        let constant2486_out1 = self.constant2486.val();
        let mul322_out1 = linear415_out1
            .mul((constant2486_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add276_out1 = add275_out1.add(mul322_out1);
        let layernormalization230_out1 = {
            let dtype = add276_out1.dtype();
            self.layernormalization230
                .forward(add276_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization231_out1 = {
            let dtype = layernormalization230_out1.clone().dtype();
            self.layernormalization231
                .forward(
                    layernormalization230_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear416_out1 = self.linear416.forward(layernormalization231_out1);
        let sigmoid185_out1 = burn::tensor::activation::sigmoid(linear416_out1.clone());
        let mul323_out1 = linear416_out1.mul(sigmoid185_out1);
        let linear417_out1 = self.linear417.forward(mul323_out1);
        let constant2487_out1 = self.constant2487.val();
        let mul324_out1 = linear417_out1
            .mul((constant2487_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add277_out1 = layernormalization230_out1.add(mul324_out1);
        let layernormalization232_out1 = {
            let dtype = add277_out1.clone().dtype();
            self.layernormalization232
                .forward(add277_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear418_out1 = self.linear418.forward(layernormalization232_out1.clone());
        let linear419_out1 = self.linear419.forward(layernormalization232_out1.clone());
        let linear420_out1 = self.linear420.forward(layernormalization232_out1);
        let constant1638_out1 = self.constant1638.val();
        let add278_out1 = linear418_out1
            .clone()
            .add((constant1638_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape187_out1 = linear418_out1.reshape([0, -1, 8, 160]);
        let transpose187_out1 = reshape187_out1.permute([0, 2, 1, 3]);
        let constant1639_out1 = self.constant1639.val();
        let add279_out1 = transpose187_out1.clone().add(constant1639_out1);
        let linear421_out1 = self.linear421.forward(reshape2_out1);
        let reshape188_out1 = linear421_out1.reshape([0, -1, 8, 160]);
        let transpose188_out1 = reshape188_out1.permute([0, 2, 3, 1]);
        let matmul469_out1 = add279_out1.matmul(transpose188_out1);
        let pad47_out1 = matmul469_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape48_out1: [i64; 4] = {
            let axes = &transpose187_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather48_out1 = shape48_out1[2] as i64;
        let unsqueeze51_out1 = [gather48_out1 as i64];
        let constant2493_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat94_out1: [i64; 4usize] = [
            &constant2493_out1[..],
            &unsqueeze51_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape189_out1 = pad47_out1.reshape(concat94_out1);
        let slice93_out1 = reshape189_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2497_out1: [i64; 2] = [0i64, 0i64];
        let constant2498_out1: [i64; 1] = [-1i64];
        let concat95_out1: [i64; 4usize] = [
            &constant2497_out1[..],
            &unsqueeze51_out1[..],
            &constant2498_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape190_out1 = slice93_out1.reshape(concat95_out1);
        let slice94_out1 = reshape190_out1.slice(s![.., .., .., 0..unsqueeze51_out1[0]]);
        let constant2501_out1 = self.constant2501.val();
        let mul325_out1 = slice94_out1
            .mul((constant2501_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention47_out1,) = {
            let q = add278_out1;
            let k = linear419_out1;
            let v = linear420_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul325_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention47_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention47_out1 = {
                let dims = attention47_out1.dims();
                attention47_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention47_out1 = attention47_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention47_out1,)
        };
        let linear422_out1 = self.linear422.forward(attention47_out1);
        let add280_out1 = add277_out1.add(linear422_out1);
        let layernormalization233_out1 = {
            let dtype = add280_out1.clone().dtype();
            self.layernormalization233
                .forward(add280_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose189_out1 = layernormalization233_out1.permute([0, 2, 1]);
        let conv1d139_out1 = self.conv1d139.forward(transpose189_out1);
        let split_tensors = conv1d139_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split47_out1, split47_out2] = split_tensors.try_into().unwrap();
        let sigmoid186_out1 = burn::tensor::activation::sigmoid(split47_out2);
        let mul326_out1 = split47_out1.mul(sigmoid186_out1);
        let conv1d140_out1 = self.conv1d140.forward(mul326_out1);
        let sigmoid187_out1 = burn::tensor::activation::sigmoid(conv1d140_out1.clone());
        let mul327_out1 = conv1d140_out1.mul(sigmoid187_out1);
        let conv1d141_out1 = self.conv1d141.forward(mul327_out1);
        let transpose190_out1 = conv1d141_out1.permute([0, 2, 1]);
        let add281_out1 = add280_out1.add(transpose190_out1);
        add281_out1
    }
}
#[derive(Module, Debug)]
pub struct Submodule39 {
    layernormalization234: LayerNorm,
    linear423: Linear,
    linear424: Linear,
    constant2503: burn::module::Param<Tensor<1>>,
    layernormalization235: LayerNorm,
    layernormalization236: LayerNorm,
    linear425: Linear,
    linear426: Linear,
    constant2504: burn::module::Param<Tensor<1>>,
    layernormalization237: LayerNorm,
    linear427: Linear,
    linear428: Linear,
    linear429: Linear,
    constant1673: burn::module::Param<Tensor<1>>,
    constant1674: burn::module::Param<Tensor<4>>,
    linear430: Linear,
    constant2518: burn::module::Param<Tensor<1>>,
    linear431: Linear,
    layernormalization238: LayerNorm,
    conv1d142: Conv1d,
    conv1d143: Conv1d,
    conv1d144: Conv1d,
    layernormalization239: LayerNorm,
    linear432: Linear,
    linear433: Linear,
    constant2520: burn::module::Param<Tensor<1>>,
    layernormalization240: LayerNorm,
    linear434: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule39 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization234 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear423 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear424 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2503: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization235 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization236 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear425 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear426 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2504: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization237 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear427 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear428 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let linear429 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let constant1673: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::zeros([1280], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1280].into(),
        );
        let constant1674: burn::module::Param<Tensor<4>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                4,
            >::zeros([1, 8, 1, 160], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 8, 1, 160].into(),
        );
        let linear430 = LinearConfig::new(1280, 1280).with_bias(false).init(device);
        let constant2518: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.07905694097280502f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear431 = LinearConfig::new(1280, 1280).with_bias(true).init(device);
        let layernormalization238 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d142 = Conv1dConfig::new(1280, 2560, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let conv1d143 = Conv1dConfig::new(1280, 1280, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Explicit(4, 4))
            .with_dilation(1)
            .with_groups(1280)
            .with_bias(true)
            .init(device);
        let conv1d144 = Conv1dConfig::new(1280, 1280, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let layernormalization239 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear432 = LinearConfig::new(1280, 5120).with_bias(true).init(device);
        let linear433 = LinearConfig::new(5120, 1280).with_bias(true).init(device);
        let constant2520: burn::module::Param<Tensor<1>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
            >::from_data(
                burn::tensor::TensorData::from([0.5f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let layernormalization240 = LayerNormConfig::new(1280)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear434 = LinearConfig::new(1280, 1024).with_bias(true).init(device);
        Self {
            layernormalization234,
            linear423,
            linear424,
            constant2503,
            layernormalization235,
            layernormalization236,
            linear425,
            linear426,
            constant2504,
            layernormalization237,
            linear427,
            linear428,
            linear429,
            constant1673,
            constant1674,
            linear430,
            constant2518,
            linear431,
            layernormalization238,
            conv1d142,
            conv1d143,
            conv1d144,
            layernormalization239,
            linear432,
            linear433,
            constant2520,
            layernormalization240,
            linear434,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add281_out1: Tensor<3>,
        reshape2_out1: Tensor<3>,
    ) -> Tensor<3> {
        let layernormalization234_out1 = {
            let dtype = add281_out1.clone().dtype();
            self.layernormalization234
                .forward(add281_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear423_out1 = self.linear423.forward(layernormalization234_out1);
        let sigmoid188_out1 = burn::tensor::activation::sigmoid(linear423_out1.clone());
        let mul328_out1 = linear423_out1.mul(sigmoid188_out1);
        let linear424_out1 = self.linear424.forward(mul328_out1);
        let constant2503_out1 = self.constant2503.val();
        let mul329_out1 = linear424_out1
            .mul((constant2503_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add282_out1 = add281_out1.add(mul329_out1);
        let layernormalization235_out1 = {
            let dtype = add282_out1.dtype();
            self.layernormalization235
                .forward(add282_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let layernormalization236_out1 = {
            let dtype = layernormalization235_out1.clone().dtype();
            self.layernormalization236
                .forward(
                    layernormalization235_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear425_out1 = self.linear425.forward(layernormalization236_out1);
        let sigmoid189_out1 = burn::tensor::activation::sigmoid(linear425_out1.clone());
        let mul330_out1 = linear425_out1.mul(sigmoid189_out1);
        let linear426_out1 = self.linear426.forward(mul330_out1);
        let constant2504_out1 = self.constant2504.val();
        let mul331_out1 = linear426_out1
            .mul((constant2504_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add283_out1 = layernormalization235_out1.add(mul331_out1);
        let layernormalization237_out1 = {
            let dtype = add283_out1.clone().dtype();
            self.layernormalization237
                .forward(add283_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear427_out1 = self.linear427.forward(layernormalization237_out1.clone());
        let linear428_out1 = self.linear428.forward(layernormalization237_out1.clone());
        let linear429_out1 = self.linear429.forward(layernormalization237_out1);
        let constant1673_out1 = self.constant1673.val();
        let add284_out1 = linear427_out1
            .clone()
            .add((constant1673_out1).unsqueeze_dims(&[0isize, 1isize]));
        let reshape191_out1 = linear427_out1.reshape([0, -1, 8, 160]);
        let transpose191_out1 = reshape191_out1.permute([0, 2, 1, 3]);
        let constant1674_out1 = self.constant1674.val();
        let add285_out1 = transpose191_out1.clone().add(constant1674_out1);
        let linear430_out1 = self.linear430.forward(reshape2_out1);
        let reshape192_out1 = linear430_out1.reshape([0, -1, 8, 160]);
        let transpose192_out1 = reshape192_out1.permute([0, 2, 3, 1]);
        let matmul479_out1 = add285_out1.matmul(transpose192_out1);
        let pad48_out1 = matmul479_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let shape49_out1: [i64; 4] = {
            let axes = &transpose191_out1.dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather49_out1 = shape49_out1[2] as i64;
        let unsqueeze52_out1 = [gather49_out1 as i64];
        let constant2510_out1: [i64; 3] = [0i64, 0i64, -1i64];
        let concat96_out1: [i64; 4usize] = [
            &constant2510_out1[..],
            &unsqueeze52_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape193_out1 = pad48_out1.reshape(concat96_out1);
        let slice95_out1 = reshape193_out1.slice(s![.., .., 1..2147483647, ..]);
        let constant2514_out1: [i64; 2] = [0i64, 0i64];
        let constant2515_out1: [i64; 1] = [-1i64];
        let concat97_out1: [i64; 4usize] = [
            &constant2514_out1[..],
            &unsqueeze52_out1[..],
            &constant2515_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape194_out1 = slice95_out1.reshape(concat97_out1);
        let slice96_out1 = reshape194_out1.slice(s![.., .., .., 0..unsqueeze52_out1[0]]);
        let constant2518_out1 = self.constant2518.val();
        let mul332_out1 = slice96_out1
            .mul((constant2518_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let (attention48_out1,) = {
            let q = add284_out1;
            let k = linear428_out1;
            let v = linear429_out1;
            let [batch_size, q_sequence_length, q_hidden_size] = q.dims();
            #[allow(clippy::identity_op)]
            let head_size = q_hidden_size / 8usize;
            let kv_sequence_length = k.dims()[1];
            #[allow(clippy::identity_op)]
            let v_head_size = v.dims()[2] / 8usize;
            let q = q
                .reshape([batch_size, q_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let k = k
                .reshape([batch_size, kv_sequence_length, 8usize, head_size])
                .permute([0, 2, 1, 3]);
            let v = v
                .reshape([batch_size, kv_sequence_length, 8usize, v_head_size])
                .permute([0, 2, 1, 3]);
            let score_bias = mul332_out1;
            let hidden_rows = score_bias
                .clone()
                .max_dim(3)
                .equal_elem(f32::NEG_INFINITY);
            let attention48_out1 = burn::tensor::module::attention(
                q,
                k,
                v,
                None,
                Some(score_bias),
                burn::tensor::ops::AttentionModuleOptions {
                    scale: Some(0.07905694097280502f64),
                    softcap: None,
                    is_causal: false,
                },
            );
            let attention48_out1 = {
                let dims = attention48_out1.dims();
                attention48_out1.mask_fill(hidden_rows.expand(dims), 0.0)
            };
            let attention48_out1 = attention48_out1
                .permute([0, 2, 1, 3])
                .reshape([batch_size as i32, q_sequence_length as i32, -1]);
            (attention48_out1,)
        };
        let linear431_out1 = self.linear431.forward(attention48_out1);
        let add286_out1 = add283_out1.add(linear431_out1);
        let layernormalization238_out1 = {
            let dtype = add286_out1.clone().dtype();
            self.layernormalization238
                .forward(add286_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose193_out1 = layernormalization238_out1.permute([0, 2, 1]);
        let conv1d142_out1 = self.conv1d142.forward(transpose193_out1);
        let split_tensors = conv1d142_out1.split_with_sizes([1280, 1280].into(), 1);
        let [split48_out1, split48_out2] = split_tensors.try_into().unwrap();
        let sigmoid190_out1 = burn::tensor::activation::sigmoid(split48_out2);
        let mul333_out1 = split48_out1.mul(sigmoid190_out1);
        let conv1d143_out1 = self.conv1d143.forward(mul333_out1);
        let sigmoid191_out1 = burn::tensor::activation::sigmoid(conv1d143_out1.clone());
        let mul334_out1 = conv1d143_out1.mul(sigmoid191_out1);
        let conv1d144_out1 = self.conv1d144.forward(mul334_out1);
        let transpose194_out1 = conv1d144_out1.permute([0, 2, 1]);
        let add287_out1 = add286_out1.add(transpose194_out1);
        let layernormalization239_out1 = {
            let dtype = add287_out1.clone().dtype();
            self.layernormalization239
                .forward(add287_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear432_out1 = self.linear432.forward(layernormalization239_out1);
        let sigmoid192_out1 = burn::tensor::activation::sigmoid(linear432_out1.clone());
        let mul335_out1 = linear432_out1.mul(sigmoid192_out1);
        let linear433_out1 = self.linear433.forward(mul335_out1);
        let constant2520_out1 = self.constant2520.val();
        let mul336_out1 = linear433_out1
            .mul((constant2520_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add288_out1 = add287_out1.add(mul336_out1);
        let layernormalization240_out1 = {
            let dtype = add288_out1.dtype();
            self.layernormalization240
                .forward(add288_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear434_out1 = self.linear434.forward(layernormalization240_out1);
        linear434_out1
    }
}

#[derive(Module, Debug)]
pub struct Model {
    submodule1: Submodule1,
    submodule2: Submodule2,
    submodule3: Submodule3,
    submodule4: Submodule4,
    submodule5: Submodule5,
    submodule6: Submodule6,
    submodule7: Submodule7,
    submodule8: Submodule8,
    submodule9: Submodule9,
    submodule10: Submodule10,
    submodule11: Submodule11,
    submodule12: Submodule12,
    submodule13: Submodule13,
    submodule14: Submodule14,
    submodule15: Submodule15,
    submodule16: Submodule16,
    submodule17: Submodule17,
    submodule18: Submodule18,
    submodule19: Submodule19,
    submodule20: Submodule20,
    submodule21: Submodule21,
    submodule22: Submodule22,
    submodule23: Submodule23,
    submodule24: Submodule24,
    submodule25: Submodule25,
    submodule26: Submodule26,
    submodule27: Submodule27,
    submodule28: Submodule28,
    submodule29: Submodule29,
    submodule30: Submodule30,
    submodule31: Submodule31,
    submodule32: Submodule32,
    submodule33: Submodule33,
    submodule34: Submodule34,
    submodule35: Submodule35,
    submodule36: Submodule36,
    submodule37: Submodule37,
    submodule38: Submodule38,
    submodule39: Submodule39,
    #[module(skip)]
    device: Device,
}





impl Model {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let submodule1 = Submodule1::new(device);
        let submodule2 = Submodule2::new(device);
        let submodule3 = Submodule3::new(device);
        let submodule4 = Submodule4::new(device);
        let submodule5 = Submodule5::new(device);
        let submodule6 = Submodule6::new(device);
        let submodule7 = Submodule7::new(device);
        let submodule8 = Submodule8::new(device);
        let submodule9 = Submodule9::new(device);
        let submodule10 = Submodule10::new(device);
        let submodule11 = Submodule11::new(device);
        let submodule12 = Submodule12::new(device);
        let submodule13 = Submodule13::new(device);
        let submodule14 = Submodule14::new(device);
        let submodule15 = Submodule15::new(device);
        let submodule16 = Submodule16::new(device);
        let submodule17 = Submodule17::new(device);
        let submodule18 = Submodule18::new(device);
        let submodule19 = Submodule19::new(device);
        let submodule20 = Submodule20::new(device);
        let submodule21 = Submodule21::new(device);
        let submodule22 = Submodule22::new(device);
        let submodule23 = Submodule23::new(device);
        let submodule24 = Submodule24::new(device);
        let submodule25 = Submodule25::new(device);
        let submodule26 = Submodule26::new(device);
        let submodule27 = Submodule27::new(device);
        let submodule28 = Submodule28::new(device);
        let submodule29 = Submodule29::new(device);
        let submodule30 = Submodule30::new(device);
        let submodule31 = Submodule31::new(device);
        let submodule32 = Submodule32::new(device);
        let submodule33 = Submodule33::new(device);
        let submodule34 = Submodule34::new(device);
        let submodule35 = Submodule35::new(device);
        let submodule36 = Submodule36::new(device);
        let submodule37 = Submodule37::new(device);
        let submodule38 = Submodule38::new(device);
        let submodule39 = Submodule39::new(device);
        Self {
            submodule1,
            submodule2,
            submodule3,
            submodule4,
            submodule5,
            submodule6,
            submodule7,
            submodule8,
            submodule9,
            submodule10,
            submodule11,
            submodule12,
            submodule13,
            submodule14,
            submodule15,
            submodule16,
            submodule17,
            submodule18,
            submodule19,
            submodule20,
            submodule21,
            submodule22,
            submodule23,
            submodule24,
            submodule25,
            submodule26,
            submodule27,
            submodule28,
            submodule29,
            submodule30,
            submodule31,
            submodule32,
            submodule33,
            submodule34,
            submodule35,
            submodule36,
            submodule37,
            submodule38,
            submodule39,
            device: device.clone(),
        }
    }

    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(&self, input_features: Tensor<3>) -> Tensor<3> {
        let (add4_out1, reshape2_out1) = self.submodule1.forward(input_features);
        let add11_out1 = self.submodule2.forward(add4_out1, reshape2_out1.clone());
        let add18_out1 = self.submodule3.forward(add11_out1, reshape2_out1.clone());
        let add25_out1 = self.submodule4.forward(add18_out1, reshape2_out1.clone());
        let add34_out1 = self.submodule5.forward(add25_out1, reshape2_out1.clone());
        let add41_out1 = self.submodule6.forward(add34_out1, reshape2_out1.clone());
        let add48_out1 = self.submodule7.forward(add41_out1, reshape2_out1.clone());
        let add55_out1 = self.submodule8.forward(add48_out1, reshape2_out1.clone());
        let add64_out1 = self.submodule9.forward(add55_out1, reshape2_out1.clone());
        let add71_out1 = self.submodule10.forward(add64_out1, reshape2_out1.clone());
        let add78_out1 = self.submodule11.forward(add71_out1, reshape2_out1.clone());
        let add85_out1 = self.submodule12.forward(add78_out1, reshape2_out1.clone());
        let add94_out1 = self.submodule13.forward(add85_out1, reshape2_out1.clone());
        let add101_out1 = self.submodule14.forward(add94_out1, reshape2_out1.clone());
        let add108_out1 = self.submodule15.forward(add101_out1, reshape2_out1.clone());
        let add115_out1 = self.submodule16.forward(add108_out1, reshape2_out1.clone());
        let add124_out1 = self.submodule17.forward(add115_out1, reshape2_out1.clone());
        let add131_out1 = self.submodule18.forward(add124_out1, reshape2_out1.clone());
        let add138_out1 = self.submodule19.forward(add131_out1, reshape2_out1.clone());
        let add145_out1 = self.submodule20.forward(add138_out1, reshape2_out1.clone());
        let add154_out1 = self.submodule21.forward(add145_out1, reshape2_out1.clone());
        let add161_out1 = self.submodule22.forward(add154_out1, reshape2_out1.clone());
        let add168_out1 = self.submodule23.forward(add161_out1, reshape2_out1.clone());
        let add175_out1 = self.submodule24.forward(add168_out1, reshape2_out1.clone());
        let add184_out1 = self.submodule25.forward(add175_out1, reshape2_out1.clone());
        let add191_out1 = self.submodule26.forward(add184_out1, reshape2_out1.clone());
        let add198_out1 = self.submodule27.forward(add191_out1, reshape2_out1.clone());
        let add205_out1 = self.submodule28.forward(add198_out1, reshape2_out1.clone());
        let add214_out1 = self.submodule29.forward(add205_out1, reshape2_out1.clone());
        let add221_out1 = self.submodule30.forward(add214_out1, reshape2_out1.clone());
        let add228_out1 = self.submodule31.forward(add221_out1, reshape2_out1.clone());
        let add235_out1 = self.submodule32.forward(add228_out1, reshape2_out1.clone());
        let add244_out1 = self.submodule33.forward(add235_out1, reshape2_out1.clone());
        let add251_out1 = self.submodule34.forward(add244_out1, reshape2_out1.clone());
        let add258_out1 = self.submodule35.forward(add251_out1, reshape2_out1.clone());
        let add265_out1 = self.submodule36.forward(add258_out1, reshape2_out1.clone());
        let add274_out1 = self.submodule37.forward(add265_out1, reshape2_out1.clone());
        let add281_out1 = self.submodule38.forward(add274_out1, reshape2_out1.clone());
        let linear434_out1 = self.submodule39.forward(add281_out1, reshape2_out1);
        linear434_out1
    }
}