parakeet-rs 0.4.2

// Generated by scripts/generate_burn.py from encoder.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,
    constant535: burn::module::Param<Tensor<1>>,
    constant536: burn::module::Param<Tensor<1>>,
    constant537: burn::module::Param<Tensor<1>>,
    constant538: burn::module::Param<Tensor<1>>,
    constant539: burn::module::Param<Tensor<1>>,
    #[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::Valid)
            .with_dilation([1, 1])
            .with_groups(1)
            .with_bias(true)
            .init(device);
        let constant535: 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([2f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant536: 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([1f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant537: 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([3f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant538: 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([2f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant539: 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([1f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            conv2d1,
            constant535,
            constant536,
            constant537,
            constant538,
            constant539,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        audio_signal: Tensor<3>,
        length: Tensor<1, Int>,
    ) -> (Tensor<4>, Tensor<1>) {
        let transpose1_out1 = audio_signal.permute([0, 2, 1]);
        let unsqueeze1_out1: Tensor<4> = transpose1_out1.unsqueeze_dims::<4>(&[1]);
        let cast1_out1 = length.float().cast(burn::tensor::DType::F32);
        let cast2_out1 = cast1_out1.clone().int().cast(burn::tensor::DType::I64);
        let shape1_out1: [i64; 4] = {
            let axes = &unsqueeze1_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather1_out1 = shape1_out1[0] as i64;
        let gather2_out1 = shape1_out1[2] as i64;
        let gather3_out1 = shape1_out1[3] as i64;
        let range1_out1 = {
            let start = 0i64;
            let delta = 1i64;
            assert!(delta != 0);
            let n = (((gather2_out1 as i128 - start 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(start)
        };
        let unsqueeze2_out1 = [gather1_out1 as i64];
        let unsqueeze3_out1 = [gather2_out1 as i64];
        let concat1_out1: [i64; 2usize] = [&unsqueeze2_out1[..], &unsqueeze3_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape1_out1 = concat1_out1;
        let constant509_out1 = -1i64;
        let mul2_out1 = {
            let mut result = reshape1_out1;
            let scalar = constant509_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max1_out1 = {
            let __lhs = reshape1_out1;
            let __rhs = mul2_out1;
            core::array::from_fn::<i64, 2usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand1_out1 = {
            let onnx_shape: [i64; 2usize] = max1_out1;
            let input_dims = range1_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..1usize {
                let dim_offset = 1usize + i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            range1_out1.expand(shape)
        };
        let unsqueeze4_out1: Tensor<2, Int> = cast2_out1.unsqueeze_dims::<2>(&[1]);
        let less1_out1 = expand1_out1.lower(unsqueeze4_out1);
        let unsqueeze5_out1: Tensor<3, Bool> = less1_out1.unsqueeze_dims::<3>(&[-1]);
        let unsqueeze6_out1 = [gather1_out1 as i64];
        let unsqueeze7_out1 = [gather2_out1 as i64];
        let unsqueeze8_out1 = [gather3_out1 as i64];
        let concat2_out1: [i64; 3usize] = [
            &unsqueeze6_out1[..],
            &unsqueeze7_out1[..],
            &unsqueeze8_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape2_out1 = concat2_out1;
        let constant517_out1 = -1i64;
        let mul4_out1 = {
            let mut result = reshape2_out1;
            let scalar = constant517_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max2_out1 = {
            let __lhs = reshape2_out1;
            let __rhs = mul4_out1;
            core::array::from_fn::<i64, 3usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand2_out1 = {
            let onnx_shape: [i64; 3usize] = max2_out1;
            let input_dims = unsqueeze5_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..3usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze5_out1.expand(shape)
        };
        let cast4_out1 = expand2_out1.float().cast(burn::tensor::DType::F32);
        let gather4_out1 = shape1_out1[1] as i64;
        let unsqueeze9_out1: Tensor<4> = cast4_out1.unsqueeze_dims::<4>(&[1]);
        let unsqueeze10_out1 = [gather1_out1 as i64];
        let unsqueeze11_out1 = [gather4_out1 as i64];
        let unsqueeze12_out1 = [gather2_out1 as i64];
        let unsqueeze13_out1 = [gather3_out1 as i64];
        let concat3_out1: [i64; 4usize] = [
            &unsqueeze10_out1[..],
            &unsqueeze11_out1[..],
            &unsqueeze12_out1[..],
            &unsqueeze13_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape3_out1 = concat3_out1;
        let constant526_out1 = -1i64;
        let mul6_out1 = {
            let mut result = reshape3_out1;
            let scalar = constant526_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max3_out1 = {
            let __lhs = reshape3_out1;
            let __rhs = mul6_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand3_out1 = {
            let onnx_shape: [i64; 4usize] = max3_out1;
            let input_dims = unsqueeze9_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze9_out1.expand(shape)
        };
        let mul7_out1 = unsqueeze1_out1.mul(expand3_out1);
        let pad1_out1 = mul7_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (2usize, 1usize), (2usize, 1usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let conv2d1_out1 = self.conv2d1.forward(pad1_out1);
        let constant535_out1 = self.constant535.val();
        let add1_out1 = cast1_out1.add(constant535_out1);
        let constant536_out1 = self.constant536.val();
        let add2_out1 = add1_out1.add(constant536_out1);
        let constant537_out1 = self.constant537.val();
        let sub1_out1 = add2_out1.sub(constant537_out1);
        let constant538_out1 = self.constant538.val();
        let div1_out1 = sub1_out1.div(constant538_out1);
        let cast6_out1 = div1_out1.int().cast(burn::tensor::DType::I64);
        let cast7_out1 = cast6_out1.float().cast(burn::tensor::DType::F32);
        let constant539_out1 = self.constant539.val();
        let add3_out1 = cast7_out1.add(constant539_out1);
        let cast8_out1 = add3_out1.clone().int().cast(burn::tensor::DType::I64);
        let shape8_out1: [i64; 4] = {
            let axes = &conv2d1_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather5_out1 = shape8_out1[0] as i64;
        let gather6_out1 = shape8_out1[2] as i64;
        let gather7_out1 = shape8_out1[3] as i64;
        let range2_out1 = {
            let start = 0i64;
            let delta = 1i64;
            assert!(delta != 0);
            let n = (((gather6_out1 as i128 - start 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(start)
        };
        let unsqueeze14_out1 = [gather5_out1 as i64];
        let unsqueeze15_out1 = [gather6_out1 as i64];
        let concat5_out1: [i64; 2usize] = [&unsqueeze14_out1[..], &unsqueeze15_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape6_out1 = concat5_out1;
        let constant549_out1 = -1i64;
        let mul9_out1 = {
            let mut result = reshape6_out1;
            let scalar = constant549_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max4_out1 = {
            let __lhs = reshape6_out1;
            let __rhs = mul9_out1;
            core::array::from_fn::<i64, 2usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand4_out1 = {
            let onnx_shape: [i64; 2usize] = max4_out1;
            let input_dims = range2_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..1usize {
                let dim_offset = 1usize + i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            range2_out1.expand(shape)
        };
        let unsqueeze16_out1: Tensor<2, Int> = cast8_out1.unsqueeze_dims::<2>(&[1]);
        let less2_out1 = expand4_out1.lower(unsqueeze16_out1);
        let unsqueeze17_out1: Tensor<3, Bool> = less2_out1.unsqueeze_dims::<3>(&[-1]);
        let unsqueeze18_out1 = [gather5_out1 as i64];
        let unsqueeze19_out1 = [gather6_out1 as i64];
        let unsqueeze20_out1 = [gather7_out1 as i64];
        let concat6_out1: [i64; 3usize] = [
            &unsqueeze18_out1[..],
            &unsqueeze19_out1[..],
            &unsqueeze20_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape7_out1 = concat6_out1;
        let constant557_out1 = -1i64;
        let mul11_out1 = {
            let mut result = reshape7_out1;
            let scalar = constant557_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max5_out1 = {
            let __lhs = reshape7_out1;
            let __rhs = mul11_out1;
            core::array::from_fn::<i64, 3usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand5_out1 = {
            let onnx_shape: [i64; 3usize] = max5_out1;
            let input_dims = unsqueeze17_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..3usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze17_out1.expand(shape)
        };
        let cast10_out1 = expand5_out1.float().cast(burn::tensor::DType::F32);
        let gather8_out1 = shape8_out1[1] as i64;
        let unsqueeze21_out1: Tensor<4> = cast10_out1.unsqueeze_dims::<4>(&[1]);
        let unsqueeze22_out1 = [gather5_out1 as i64];
        let unsqueeze23_out1 = [gather8_out1 as i64];
        let unsqueeze24_out1 = [gather6_out1 as i64];
        let unsqueeze25_out1 = [gather7_out1 as i64];
        let concat7_out1: [i64; 4usize] = [
            &unsqueeze22_out1[..],
            &unsqueeze23_out1[..],
            &unsqueeze24_out1[..],
            &unsqueeze25_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape8_out1 = concat7_out1;
        let constant566_out1 = -1i64;
        let mul13_out1 = {
            let mut result = reshape8_out1;
            let scalar = constant566_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max6_out1 = {
            let __lhs = reshape8_out1;
            let __rhs = mul13_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand6_out1 = {
            let onnx_shape: [i64; 4usize] = max6_out1;
            let input_dims = unsqueeze21_out1.clone().dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze21_out1.clone().expand(shape)
        };
        let mul14_out1 = conv2d1_out1.mul(expand6_out1);
        let relu1_out1 = burn::tensor::activation::relu(mul14_out1);
        let shape15_out1: [i64; 4] = {
            let axes = &relu1_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather9_out1 = shape15_out1[0] as i64;
        let gather10_out1 = shape15_out1[1] as i64;
        let gather11_out1 = shape15_out1[2] as i64;
        let gather12_out1 = shape15_out1[3] as i64;
        let unsqueeze26_out1 = [gather9_out1 as i64];
        let unsqueeze27_out1 = [gather10_out1 as i64];
        let unsqueeze28_out1 = [gather11_out1 as i64];
        let unsqueeze29_out1 = [gather12_out1 as i64];
        let concat8_out1: [i64; 4usize] = [
            &unsqueeze26_out1[..],
            &unsqueeze27_out1[..],
            &unsqueeze28_out1[..],
            &unsqueeze29_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape9_out1 = concat8_out1;
        let constant577_out1 = -1i64;
        let mul16_out1 = {
            let mut result = reshape9_out1;
            let scalar = constant577_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max7_out1 = {
            let __lhs = reshape9_out1;
            let __rhs = mul16_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand7_out1 = {
            let onnx_shape: [i64; 4usize] = max7_out1;
            let input_dims = unsqueeze21_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze21_out1.expand(shape)
        };
        let mul17_out1 = relu1_out1.mul(expand7_out1);
        (mul17_out1, add3_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule2 {
    conv2d2: Conv2d,
    constant586: burn::module::Param<Tensor<1>>,
    constant587: burn::module::Param<Tensor<1>>,
    constant588: burn::module::Param<Tensor<1>>,
    constant589: burn::module::Param<Tensor<1>>,
    constant590: burn::module::Param<Tensor<1>>,
    conv2d3: Conv2d,
    #[module(skip)]
    device: Device,
}
impl Submodule2 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let conv2d2 = Conv2dConfig::new([256, 256], [3, 3])
            .with_stride([2, 2])
            .with_padding(PaddingConfig2d::Valid)
            .with_dilation([1, 1])
            .with_groups(256)
            .with_bias(true)
            .init(device);
        let constant586: 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([2f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant587: 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([1f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant588: 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([3f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant589: 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([2f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant590: 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([1f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        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);
        Self {
            conv2d2,
            constant586,
            constant587,
            constant588,
            constant589,
            constant590,
            conv2d3,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        mul17_out1: Tensor<4>,
        add3_out1: Tensor<1>,
    ) -> (Tensor<4>, Tensor<1>) {
        let pad2_out1 = mul17_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (2usize, 1usize), (2usize, 1usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let conv2d2_out1 = self.conv2d2.forward(pad2_out1);
        let constant586_out1 = self.constant586.val();
        let add4_out1 = add3_out1.add(constant586_out1);
        let constant587_out1 = self.constant587.val();
        let add5_out1 = add4_out1.add(constant587_out1);
        let constant588_out1 = self.constant588.val();
        let sub2_out1 = add5_out1.sub(constant588_out1);
        let constant589_out1 = self.constant589.val();
        let div2_out1 = sub2_out1.div(constant589_out1);
        let cast12_out1 = div2_out1.int().cast(burn::tensor::DType::I64);
        let cast13_out1 = cast12_out1.float().cast(burn::tensor::DType::F32);
        let constant590_out1 = self.constant590.val();
        let add6_out1 = cast13_out1.add(constant590_out1);
        let cast14_out1 = add6_out1.clone().int().cast(burn::tensor::DType::I64);
        let shape20_out1: [i64; 4] = {
            let axes = &conv2d2_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather13_out1 = shape20_out1[0] as i64;
        let gather14_out1 = shape20_out1[2] as i64;
        let gather15_out1 = shape20_out1[3] as i64;
        let range3_out1 = {
            let start = 0i64;
            let delta = 1i64;
            assert!(delta != 0);
            let n = (((gather14_out1 as i128 - start 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(start)
        };
        let unsqueeze30_out1 = [gather13_out1 as i64];
        let unsqueeze31_out1 = [gather14_out1 as i64];
        let concat10_out1: [i64; 2usize] = [&unsqueeze30_out1[..], &unsqueeze31_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape12_out1 = concat10_out1;
        let constant600_out1 = -1i64;
        let mul19_out1 = {
            let mut result = reshape12_out1;
            let scalar = constant600_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max8_out1 = {
            let __lhs = reshape12_out1;
            let __rhs = mul19_out1;
            core::array::from_fn::<i64, 2usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand8_out1 = {
            let onnx_shape: [i64; 2usize] = max8_out1;
            let input_dims = range3_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..1usize {
                let dim_offset = 1usize + i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            range3_out1.expand(shape)
        };
        let unsqueeze32_out1: Tensor<2, Int> = cast14_out1.unsqueeze_dims::<2>(&[1]);
        let less3_out1 = expand8_out1.lower(unsqueeze32_out1);
        let unsqueeze33_out1: Tensor<3, Bool> = less3_out1.unsqueeze_dims::<3>(&[-1]);
        let unsqueeze34_out1 = [gather13_out1 as i64];
        let unsqueeze35_out1 = [gather14_out1 as i64];
        let unsqueeze36_out1 = [gather15_out1 as i64];
        let concat11_out1: [i64; 3usize] = [
            &unsqueeze34_out1[..],
            &unsqueeze35_out1[..],
            &unsqueeze36_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape13_out1 = concat11_out1;
        let constant608_out1 = -1i64;
        let mul21_out1 = {
            let mut result = reshape13_out1;
            let scalar = constant608_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max9_out1 = {
            let __lhs = reshape13_out1;
            let __rhs = mul21_out1;
            core::array::from_fn::<i64, 3usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand9_out1 = {
            let onnx_shape: [i64; 3usize] = max9_out1;
            let input_dims = unsqueeze33_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..3usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze33_out1.expand(shape)
        };
        let cast16_out1 = expand9_out1.float().cast(burn::tensor::DType::F32);
        let gather16_out1 = shape20_out1[1] as i64;
        let unsqueeze37_out1: Tensor<4> = cast16_out1.unsqueeze_dims::<4>(&[1]);
        let unsqueeze38_out1 = [gather13_out1 as i64];
        let unsqueeze39_out1 = [gather16_out1 as i64];
        let unsqueeze40_out1 = [gather14_out1 as i64];
        let unsqueeze41_out1 = [gather15_out1 as i64];
        let concat12_out1: [i64; 4usize] = [
            &unsqueeze38_out1[..],
            &unsqueeze39_out1[..],
            &unsqueeze40_out1[..],
            &unsqueeze41_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape14_out1 = concat12_out1;
        let constant617_out1 = -1i64;
        let mul23_out1 = {
            let mut result = reshape14_out1;
            let scalar = constant617_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max10_out1 = {
            let __lhs = reshape14_out1;
            let __rhs = mul23_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand10_out1 = {
            let onnx_shape: [i64; 4usize] = max10_out1;
            let input_dims = unsqueeze37_out1.clone().dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze37_out1.clone().expand(shape)
        };
        let mul24_out1 = conv2d2_out1.mul(expand10_out1);
        let conv2d3_out1 = self.conv2d3.forward(mul24_out1);
        let shape27_out1: [i64; 4] = {
            let axes = &conv2d3_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather17_out1 = shape27_out1[0] as i64;
        let gather18_out1 = shape27_out1[1] as i64;
        let gather19_out1 = shape27_out1[2] as i64;
        let gather20_out1 = shape27_out1[3] as i64;
        let unsqueeze42_out1 = [gather17_out1 as i64];
        let unsqueeze43_out1 = [gather18_out1 as i64];
        let unsqueeze44_out1 = [gather19_out1 as i64];
        let unsqueeze45_out1 = [gather20_out1 as i64];
        let concat13_out1: [i64; 4usize] = [
            &unsqueeze42_out1[..],
            &unsqueeze43_out1[..],
            &unsqueeze44_out1[..],
            &unsqueeze45_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape15_out1 = concat13_out1;
        let constant628_out1 = -1i64;
        let mul26_out1 = {
            let mut result = reshape15_out1;
            let scalar = constant628_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max11_out1 = {
            let __lhs = reshape15_out1;
            let __rhs = mul26_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand11_out1 = {
            let onnx_shape: [i64; 4usize] = max11_out1;
            let input_dims = unsqueeze37_out1.clone().dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze37_out1.clone().expand(shape)
        };
        let mul27_out1 = conv2d3_out1.mul(expand11_out1);
        let relu2_out1 = burn::tensor::activation::relu(mul27_out1);
        let shape32_out1: [i64; 4] = {
            let axes = &relu2_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather21_out1 = shape32_out1[0] as i64;
        let gather22_out1 = shape32_out1[1] as i64;
        let gather23_out1 = shape32_out1[2] as i64;
        let gather24_out1 = shape32_out1[3] as i64;
        let unsqueeze46_out1 = [gather21_out1 as i64];
        let unsqueeze47_out1 = [gather22_out1 as i64];
        let unsqueeze48_out1 = [gather23_out1 as i64];
        let unsqueeze49_out1 = [gather24_out1 as i64];
        let concat14_out1: [i64; 4usize] = [
            &unsqueeze46_out1[..],
            &unsqueeze47_out1[..],
            &unsqueeze48_out1[..],
            &unsqueeze49_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape16_out1 = concat14_out1;
        let constant639_out1 = -1i64;
        let mul29_out1 = {
            let mut result = reshape16_out1;
            let scalar = constant639_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max12_out1 = {
            let __lhs = reshape16_out1;
            let __rhs = mul29_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand12_out1 = {
            let onnx_shape: [i64; 4usize] = max12_out1;
            let input_dims = unsqueeze37_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze37_out1.expand(shape)
        };
        let mul30_out1 = relu2_out1.mul(expand12_out1);
        (mul30_out1, add6_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule3 {
    conv2d4: Conv2d,
    constant648: burn::module::Param<Tensor<1>>,
    constant649: burn::module::Param<Tensor<1>>,
    constant650: burn::module::Param<Tensor<1>>,
    constant651: burn::module::Param<Tensor<1>>,
    constant652: burn::module::Param<Tensor<1>>,
    conv2d5: Conv2d,
    #[module(skip)]
    device: Device,
}
impl Submodule3 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let conv2d4 = Conv2dConfig::new([256, 256], [3, 3])
            .with_stride([2, 2])
            .with_padding(PaddingConfig2d::Valid)
            .with_dilation([1, 1])
            .with_groups(256)
            .with_bias(true)
            .init(device);
        let constant648: 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([2f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant649: 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([1f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant650: 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([3f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant651: 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([2f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant652: 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([1f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        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);
        Self {
            conv2d4,
            constant648,
            constant649,
            constant650,
            constant651,
            constant652,
            conv2d5,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        mul30_out1: Tensor<4>,
        add6_out1: Tensor<1>,
    ) -> (Tensor<4>, Tensor<1, Int>) {
        let pad3_out1 = mul30_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (2usize, 1usize), (2usize, 1usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let conv2d4_out1 = self.conv2d4.forward(pad3_out1);
        let constant648_out1 = self.constant648.val();
        let add7_out1 = add6_out1.add(constant648_out1);
        let constant649_out1 = self.constant649.val();
        let add8_out1 = add7_out1.add(constant649_out1);
        let constant650_out1 = self.constant650.val();
        let sub3_out1 = add8_out1.sub(constant650_out1);
        let constant651_out1 = self.constant651.val();
        let div3_out1 = sub3_out1.div(constant651_out1);
        let cast18_out1 = div3_out1.int().cast(burn::tensor::DType::I64);
        let cast19_out1 = cast18_out1.float().cast(burn::tensor::DType::F32);
        let constant652_out1 = self.constant652.val();
        let add9_out1 = cast19_out1.add(constant652_out1);
        let cast20_out1 = add9_out1.int().cast(burn::tensor::DType::I64);
        let shape37_out1: [i64; 4] = {
            let axes = &conv2d4_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather25_out1 = shape37_out1[0] as i64;
        let gather26_out1 = shape37_out1[2] as i64;
        let gather27_out1 = shape37_out1[3] as i64;
        let range4_out1 = {
            let start = 0i64;
            let delta = 1i64;
            assert!(delta != 0);
            let n = (((gather26_out1 as i128 - start 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(start)
        };
        let unsqueeze50_out1 = [gather25_out1 as i64];
        let unsqueeze51_out1 = [gather26_out1 as i64];
        let concat16_out1: [i64; 2usize] = [&unsqueeze50_out1[..], &unsqueeze51_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape19_out1 = concat16_out1;
        let constant662_out1 = -1i64;
        let mul32_out1 = {
            let mut result = reshape19_out1;
            let scalar = constant662_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max13_out1 = {
            let __lhs = reshape19_out1;
            let __rhs = mul32_out1;
            core::array::from_fn::<i64, 2usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand13_out1 = {
            let onnx_shape: [i64; 2usize] = max13_out1;
            let input_dims = range4_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..1usize {
                let dim_offset = 1usize + i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            range4_out1.expand(shape)
        };
        let unsqueeze52_out1: Tensor<2, Int> = cast20_out1
            .clone()
            .unsqueeze_dims::<2>(&[1]);
        let less4_out1 = expand13_out1.lower(unsqueeze52_out1);
        let unsqueeze53_out1: Tensor<3, Bool> = less4_out1.unsqueeze_dims::<3>(&[-1]);
        let unsqueeze54_out1 = [gather25_out1 as i64];
        let unsqueeze55_out1 = [gather26_out1 as i64];
        let unsqueeze56_out1 = [gather27_out1 as i64];
        let concat17_out1: [i64; 3usize] = [
            &unsqueeze54_out1[..],
            &unsqueeze55_out1[..],
            &unsqueeze56_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape20_out1 = concat17_out1;
        let constant670_out1 = -1i64;
        let mul34_out1 = {
            let mut result = reshape20_out1;
            let scalar = constant670_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max14_out1 = {
            let __lhs = reshape20_out1;
            let __rhs = mul34_out1;
            core::array::from_fn::<i64, 3usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand14_out1 = {
            let onnx_shape: [i64; 3usize] = max14_out1;
            let input_dims = unsqueeze53_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..3usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze53_out1.expand(shape)
        };
        let cast22_out1 = expand14_out1.float().cast(burn::tensor::DType::F32);
        let gather28_out1 = shape37_out1[1] as i64;
        let unsqueeze57_out1: Tensor<4> = cast22_out1.unsqueeze_dims::<4>(&[1]);
        let unsqueeze58_out1 = [gather25_out1 as i64];
        let unsqueeze59_out1 = [gather28_out1 as i64];
        let unsqueeze60_out1 = [gather26_out1 as i64];
        let unsqueeze61_out1 = [gather27_out1 as i64];
        let concat18_out1: [i64; 4usize] = [
            &unsqueeze58_out1[..],
            &unsqueeze59_out1[..],
            &unsqueeze60_out1[..],
            &unsqueeze61_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape21_out1 = concat18_out1;
        let constant679_out1 = -1i64;
        let mul36_out1 = {
            let mut result = reshape21_out1;
            let scalar = constant679_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max15_out1 = {
            let __lhs = reshape21_out1;
            let __rhs = mul36_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand15_out1 = {
            let onnx_shape: [i64; 4usize] = max15_out1;
            let input_dims = unsqueeze57_out1.clone().dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze57_out1.clone().expand(shape)
        };
        let mul37_out1 = conv2d4_out1.mul(expand15_out1);
        let conv2d5_out1 = self.conv2d5.forward(mul37_out1);
        let shape44_out1: [i64; 4] = {
            let axes = &conv2d5_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather29_out1 = shape44_out1[0] as i64;
        let gather30_out1 = shape44_out1[1] as i64;
        let gather31_out1 = shape44_out1[2] as i64;
        let gather32_out1 = shape44_out1[3] as i64;
        let unsqueeze62_out1 = [gather29_out1 as i64];
        let unsqueeze63_out1 = [gather30_out1 as i64];
        let unsqueeze64_out1 = [gather31_out1 as i64];
        let unsqueeze65_out1 = [gather32_out1 as i64];
        let concat19_out1: [i64; 4usize] = [
            &unsqueeze62_out1[..],
            &unsqueeze63_out1[..],
            &unsqueeze64_out1[..],
            &unsqueeze65_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape22_out1 = concat19_out1;
        let constant690_out1 = -1i64;
        let mul39_out1 = {
            let mut result = reshape22_out1;
            let scalar = constant690_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max16_out1 = {
            let __lhs = reshape22_out1;
            let __rhs = mul39_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand16_out1 = {
            let onnx_shape: [i64; 4usize] = max16_out1;
            let input_dims = unsqueeze57_out1.clone().dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze57_out1.clone().expand(shape)
        };
        let mul40_out1 = conv2d5_out1.mul(expand16_out1);
        let relu3_out1 = burn::tensor::activation::relu(mul40_out1);
        let shape49_out1: [i64; 4] = {
            let axes = &relu3_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather33_out1 = shape49_out1[0] as i64;
        let gather34_out1 = shape49_out1[1] as i64;
        let gather35_out1 = shape49_out1[2] as i64;
        let gather36_out1 = shape49_out1[3] as i64;
        let unsqueeze66_out1 = [gather33_out1 as i64];
        let unsqueeze67_out1 = [gather34_out1 as i64];
        let unsqueeze68_out1 = [gather35_out1 as i64];
        let unsqueeze69_out1 = [gather36_out1 as i64];
        let concat20_out1: [i64; 4usize] = [
            &unsqueeze66_out1[..],
            &unsqueeze67_out1[..],
            &unsqueeze68_out1[..],
            &unsqueeze69_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape23_out1 = concat20_out1;
        let constant701_out1 = -1i64;
        let mul42_out1 = {
            let mut result = reshape23_out1;
            let scalar = constant701_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max17_out1 = {
            let __lhs = reshape23_out1;
            let __rhs = mul42_out1;
            core::array::from_fn::<i64, 4usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand17_out1 = {
            let onnx_shape: [i64; 4usize] = max17_out1;
            let input_dims = unsqueeze57_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..4usize {
                let dim_offset = i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            unsqueeze57_out1.expand(shape)
        };
        let mul43_out1 = relu3_out1.mul(expand17_out1);
        (mul43_out1, cast20_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule4 {
    linear1: Linear,
    constant711: burn::module::Param<Tensor<1, Int>>,
    constant715: burn::module::Param<Tensor<1, Int>>,
    constant716: burn::module::Param<Tensor<1, Int>>,
    constant720: burn::module::Param<Tensor<3>>,
    constant731: burn::module::Param<Tensor<1, Int>>,
    #[module(skip)]
    device: Device,
}
impl Submodule4 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let linear1 = LinearConfig::new(4352, 512).with_bias(true).init(device);
        let constant711: burn::module::Param<Tensor<1, Int>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
                Int,
            >::from_data(
                burn::tensor::TensorData::from([2i64]),
                (device, burn::tensor::DType::I64),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant715: burn::module::Param<Tensor<1, Int>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
                Int,
            >::from_data(
                burn::tensor::TensorData::from([70i64]),
                (device, burn::tensor::DType::I64),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant716: burn::module::Param<Tensor<1, Int>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
                Int,
            >::from_data(
                burn::tensor::TensorData::from([70i64]),
                (device, burn::tensor::DType::I64),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let constant720: burn::module::Param<Tensor<3>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                3,
            >::zeros([1, 9999, 512], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [1, 9999, 512].into(),
        );
        let constant731: burn::module::Param<Tensor<1, Int>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                1,
                Int,
            >::from_data(
                burn::tensor::TensorData::from([2i64]),
                (device, burn::tensor::DType::I32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        Self {
            linear1,
            constant711,
            constant715,
            constant716,
            constant720,
            constant731,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        mul43_out1: Tensor<4>,
        cast20_out1: Tensor<1, Int>,
        cache_last_channel_len: Tensor<1, Int>,
    ) -> (Tensor<3, Bool>, Tensor<2, Bool>, Tensor<3>, Tensor<3>, i64, Tensor<1, Int>) {
        let shape54_out1: [i64; 4] = {
            let axes = &mul43_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather37_out1 = shape54_out1[0] as i64;
        let gather38_out1 = shape54_out1[2] as i64;
        let transpose5_out1 = mul43_out1.permute([0, 2, 1, 3]);
        let unsqueeze70_out1 = [gather37_out1 as i64];
        let unsqueeze71_out1 = [gather38_out1 as i64];
        let constant706_out1: [i64; 1] = [-1i64];
        let concat21_out1: [i64; 3usize] = [
            &unsqueeze70_out1[..],
            &unsqueeze71_out1[..],
            &constant706_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape24_out1 = transpose5_out1.reshape(concat21_out1);
        let linear1_out1 = self.linear1.forward(reshape24_out1);
        let slice4_out1 = linear1_out1.slice(s![.., 2.., ..]);
        let constant711_out1 = self.constant711.val();
        let sub4_out1 = cast20_out1.sub(constant711_out1);
        let clip1_out1 = sub4_out1.clamp_min(0f64);
        let shape56_out1: [i64; 3] = {
            let axes = &slice4_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather39_out1 = shape56_out1[1] as i64;
        let constant714_out1 = 70i64;
        let add10_out1 = gather39_out1 + constant714_out1;
        let constant715_out1 = self.constant715.val();
        let add11_out1 = clip1_out1.clone().add(constant715_out1);
        let neg1_out1 = cache_last_channel_len.neg();
        let constant716_out1 = self.constant716.val();
        let add12_out1 = neg1_out1.add(constant716_out1);
        let constant717_out1 = 5000i64;
        let sub5_out1 = constant717_out1 - add10_out1;
        let constant718_out1 = 5000i64;
        let add13_out1 = constant718_out1 + add10_out1;
        let constant719_out1 = 1i64;
        let sub6_out1 = add13_out1 - constant719_out1;
        let unsqueeze72_out1 = [sub5_out1 as i64];
        let unsqueeze73_out1 = [sub6_out1 as i64];
        let constant720_out1 = self.constant720.val();
        let slice5_out1 = constant720_out1
            .slice(s![.., unsqueeze72_out1[0]..unsqueeze73_out1[0], ..]);
        let unsqueeze74_out1 = [add10_out1 as i64];
        let unsqueeze75_out1 = [add10_out1 as i64];
        let constant725_out1: [i64; 1] = [1i64];
        let concat22_out1: [i64; 3usize] = [
            &constant725_out1[..],
            &unsqueeze74_out1[..],
            &unsqueeze75_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let constantofshape21_out1 = Tensor::<3, Int>::ones(concat22_out1, &self.device)
            .bool();
        let cast24_out1 = add10_out1;
        let range5_out1 = {
            let start = 0i32;
            let delta = 1i32;
            assert!(delta != 0);
            let n = (((cast24_out1 as i128 - start as i128) as f64) / delta as f64)
                .ceil()
                .max(0.0) as i64;
            Tensor::arange(0..n, &self.device)
                .cast(burn::tensor::DType::I32)
                .mul_scalar(delta)
                .add_scalar(start)
        };
        let constant731_out1 = self.constant731.val();
        let div4_out1 = range5_out1.div(constant731_out1);
        let cast25_out1 = div4_out1.cast(burn::tensor::DType::I64);
        let cast26_out1 = cast25_out1.cast(burn::tensor::DType::I32);
        let unsqueeze76_out1: Tensor<2, Int> = cast26_out1
            .clone()
            .unsqueeze_dims::<2>(&[1]);
        let unsqueeze77_out1: Tensor<2, Int> = cast26_out1.unsqueeze_dims::<2>(&[0]);
        let sub7_out1 = unsqueeze76_out1.sub(unsqueeze77_out1);
        let cast27_out1 = sub7_out1.cast(burn::tensor::DType::I64);
        let constant734_out1 = 35i64;
        let lessorequal1_out1 = cast27_out1.clone().lower_equal_elem(constant734_out1);
        let constant735_out1 = 0i64;
        let greaterorequal1_out1 = cast27_out1.greater_equal_elem(constant735_out1);
        let and1_out1 = lessorequal1_out1.bool_and(greaterorequal1_out1);
        let unsqueeze78_out1: Tensor<3, Bool> = and1_out1.unsqueeze_dims::<3>(&[0]);
        let and2_out1 = constantofshape21_out1.bool_and(unsqueeze78_out1);
        let range6_out1 = {
            let start = 0i64;
            let delta = 1i64;
            assert!(delta != 0);
            let n = (((add10_out1 as i128 - start 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(start)
        };
        let shape57_out1: [i64; 1] = {
            let axes = &add11_out1.clone().dims()[0..1];
            let mut output = [0i64; 1];
            for i in 0..1 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather40_out1 = shape57_out1[0] as i64;
        let unsqueeze79_out1 = [gather40_out1 as i64];
        let constant741_out1: [i64; 1] = [-1i64];
        let concat23_out1: [i64; 2usize] = [&unsqueeze79_out1[..], &constant741_out1[..]]
            .concat()
            .try_into()
            .unwrap();
        let reshape25_out1 = concat23_out1;
        let constant744_out1 = -1i64;
        let mul45_out1 = {
            let mut result = reshape25_out1;
            let scalar = constant744_out1;
            for result_item in result.iter_mut() {
                *result_item = result_item.saturating_mul(scalar);
            }
            result
        };
        let max18_out1 = {
            let __lhs = reshape25_out1;
            let __rhs = mul45_out1;
            core::array::from_fn::<i64, 2usize, _>(|__i| (__lhs[__i]).max(__rhs[__i]))
        };
        let expand18_out1 = {
            let onnx_shape: [i64; 2usize] = max18_out1;
            let input_dims = range6_out1.dims();
            let mut shape = onnx_shape;
            #[allow(clippy::needless_range_loop)]
            for i in 0..1usize {
                let dim_offset = 1usize + i;
                if shape[dim_offset] == 1 && input_dims[i] > 1 {
                    shape[dim_offset] = input_dims[i] as i64;
                }
            }
            range6_out1.expand(shape)
        };
        let unsqueeze80_out1: Tensor<2, Int> = add11_out1.unsqueeze_dims::<2>(&[-1]);
        let less5_out1 = expand18_out1.clone().lower(unsqueeze80_out1);
        let unsqueeze81_out1: Tensor<2, Int> = add12_out1.unsqueeze_dims::<2>(&[-1]);
        let greaterorequal2_out1 = expand18_out1.greater_equal(unsqueeze81_out1);
        let and3_out1 = greaterorequal2_out1.bool_and(less5_out1);
        let unsqueeze82_out1: Tensor<3, Bool> = and3_out1
            .clone()
            .unsqueeze_dims::<3>(&[1]);
        let unsqueeze84_out1 = [add10_out1 as i64];
        let constant753_out1: [i64; 1] = [1i64];
        let constant751_out1: [i64; 1] = [1i64];
        let concat25_out1: [i64; 3usize] = [
            &constant751_out1[..],
            &unsqueeze84_out1[..],
            &constant753_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let tile1_out1 = {
            let repeats: alloc::vec::Vec<usize> = concat25_out1
                .iter()
                .map(|&v| v as usize)
                .collect();
            unsqueeze82_out1.repeat(&repeats)
        };
        let transpose6_out1 = tile1_out1.clone().permute([0, 2, 1]);
        let and4_out1 = tile1_out1.bool_and(transpose6_out1);
        let unsqueeze85_out1 = [add10_out1 as i64];
        let slice6_out1 = and2_out1.slice(s![.., 0..unsqueeze85_out1[0], ..]);
        let unsqueeze86_out1 = [add10_out1 as i64];
        let slice7_out1 = slice6_out1.slice(s![.., .., 0..unsqueeze86_out1[0]]);
        let and5_out1 = and4_out1.bool_and(slice7_out1);
        (and5_out1, and3_out1, slice4_out1, slice5_out1, gather39_out1, clip1_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule5 {
    layernormalization1: LayerNorm,
    linear2: Linear,
    linear3: Linear,
    constant770: burn::module::Param<Tensor<1>>,
    layernormalization2: LayerNorm,
    linear4: Linear,
    linear5: Linear,
    linear6: Linear,
    linear7: Linear,
    constant23: burn::module::Param<Tensor<2>>,
    constant24: burn::module::Param<Tensor<2>>,
    constant895: burn::module::Param<Tensor<1>>,
    linear8: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule5 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization1 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear2 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear3 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant770: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear4 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear5 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear6 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear7 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant23: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant24: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant895: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear8 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization1,
            linear2,
            linear3,
            constant770,
            layernormalization2,
            linear4,
            linear5,
            linear6,
            linear7,
            constant23,
            constant24,
            constant895,
            linear8,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        and5_out1: Tensor<3, Bool>,
        and3_out1: Tensor<2, Bool>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice4_out1: Tensor<3>,
        slice5_out1: Tensor<3>,
    ) -> (Tensor<3>, Tensor<2, Bool>, Tensor<3>, Tensor<4, Bool>, Tensor<3>) {
        let not1_out1 = and5_out1.bool_not();
        let not2_out1 = and3_out1.bool_not();
        let slice8_out1 = not2_out1.slice(s![.., 70..]);
        let slice9_out1 = not1_out1.slice(s![.., 70.., ..]);
        let gather41_out1 = {
            let sliced = cache_last_channel.slice(s![0, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather42_out1 = {
            let sliced = cache_last_time.slice(s![0, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization1_out1 = {
            let dtype = slice4_out1.clone().dtype();
            self.layernormalization1
                .forward(slice4_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 mul46_out1 = linear2_out1.mul(sigmoid1_out1);
        let linear3_out1 = self.linear3.forward(mul46_out1);
        let constant770_out1 = self.constant770.val();
        let mul47_out1 = linear3_out1
            .mul((constant770_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add14_out1 = slice4_out1.add(mul47_out1);
        let layernormalization2_out1 = {
            let dtype = add14_out1.clone().dtype();
            self.layernormalization2
                .forward(add14_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat26_out1 = burn::tensor::Tensor::cat(
            [gather41_out1.clone(), layernormalization2_out1.clone()].into(),
            1,
        );
        let shape60_out1: [i64; 3] = {
            let axes = &layernormalization2_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather43_out1 = shape60_out1[1] as i64;
        let unsqueeze87_out1 = [gather43_out1 as i64];
        let slice10_out1 = gather41_out1
            .slice(s![.., unsqueeze87_out1[0]..9223372036854775807, ..]);
        let unsqueeze88_out1 = [gather43_out1 as i64];
        let slice11_out1 = layernormalization2_out1
            .clone()
            .slice(s![.., 0..unsqueeze88_out1[0], ..]);
        let concat27_out1 = burn::tensor::Tensor::cat(
            [slice10_out1, slice11_out1].into(),
            1,
        );
        let gather44_out1 = shape60_out1[0] as i64;
        let linear4_out1 = self.linear4.forward(layernormalization2_out1);
        let unsqueeze89_out1 = [gather44_out1 as i64];
        let constant785_out1: [i64; 1] = [64i64];
        let constant783_out1: [i64; 1] = [-1i64];
        let constant784_out1: [i64; 1] = [8i64];
        let concat28_out1: [i64; 4usize] = [
            &unsqueeze89_out1[..],
            &constant783_out1[..],
            &constant784_out1[..],
            &constant785_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze90_out1 = [gather44_out1 as i64];
        let constant789_out1: [i64; 1] = [64i64];
        let constant787_out1: [i64; 1] = [-1i64];
        let constant788_out1: [i64; 1] = [8i64];
        let concat29_out1: [i64; 4usize] = [
            &unsqueeze90_out1[..],
            &constant787_out1[..],
            &constant788_out1[..],
            &constant789_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze91_out1 = [gather44_out1 as i64];
        let constant793_out1: [i64; 1] = [64i64];
        let constant791_out1: [i64; 1] = [-1i64];
        let constant792_out1: [i64; 1] = [8i64];
        let concat30_out1: [i64; 4usize] = [
            &unsqueeze91_out1[..],
            &constant791_out1[..],
            &constant792_out1[..],
            &constant793_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape26_out1 = linear4_out1.reshape(concat28_out1);
        let linear5_out1 = self.linear5.forward(concat26_out1.clone());
        let reshape27_out1 = linear5_out1.reshape(concat29_out1);
        let linear6_out1 = self.linear6.forward(concat26_out1);
        let reshape28_out1 = linear6_out1.reshape(concat30_out1);
        let transpose7_out1 = reshape28_out1.permute([0, 2, 1, 3]);
        let linear7_out1 = self.linear7.forward(slice5_out1);
        let reshape29_out1 = linear7_out1.reshape([1, -1, 8, 64]);
        let constant23_out1 = self.constant23.val();
        let add15_out1 = reshape26_out1
            .clone()
            .add((constant23_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose8_out1 = add15_out1.permute([0, 2, 1, 3]);
        let constant24_out1 = self.constant24.val();
        let add16_out1 = reshape26_out1
            .add((constant24_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose9_out1 = add16_out1.permute([0, 2, 1, 3]);
        let transpose10_out1 = reshape29_out1.permute([0, 2, 3, 1]);
        let matmul8_out1 = transpose9_out1.matmul(transpose10_out1);
        let shape63_out1: [i64; 4] = {
            let axes = &matmul8_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather46_out1 = shape63_out1[0] as i64;
        let gather47_out1 = shape63_out1[1] as i64;
        let gather48_out1 = shape63_out1[2] as i64;
        let gather49_out1 = shape63_out1[3] as i64;
        let pad4_out1 = matmul8_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze109_out1 = [gather46_out1 as i64];
        let unsqueeze110_out1 = [gather47_out1 as i64];
        let unsqueeze111_out1 = [gather48_out1 as i64];
        let constant877_out1: [i64; 1] = [-1i64];
        let concat49_out1: [i64; 4usize] = [
            &unsqueeze109_out1[..],
            &unsqueeze110_out1[..],
            &constant877_out1[..],
            &unsqueeze111_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape32_out1 = pad4_out1.reshape(concat49_out1);
        let slice13_out1 = reshape32_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze112_out1 = [gather46_out1 as i64];
        let unsqueeze113_out1 = [gather47_out1 as i64];
        let unsqueeze114_out1 = [gather48_out1 as i64];
        let unsqueeze115_out1 = [gather49_out1 as i64];
        let concat50_out1: [i64; 4usize] = [
            &unsqueeze112_out1[..],
            &unsqueeze113_out1[..],
            &unsqueeze114_out1[..],
            &unsqueeze115_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape33_out1 = slice13_out1.reshape(concat50_out1);
        let transpose12_out1 = reshape27_out1.permute([0, 2, 3, 1]);
        let matmul9_out1 = transpose8_out1.matmul(transpose12_out1);
        let shape67_out1: [i64; 4] = {
            let axes = &matmul9_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice14_out1: [i64; 1] = shape67_out1[3..4].try_into().unwrap();
        let squeeze1_out1 = slice14_out1[0] as i64;
        let unsqueeze116_out1 = [squeeze1_out1 as i64];
        let slice15_out1 = reshape33_out1.slice(s![.., .., .., 0..unsqueeze116_out1[0]]);
        let add17_out1 = matmul9_out1.add(slice15_out1);
        let constant895_out1 = self.constant895.val();
        let div5_out1 = add17_out1
            .div((constant895_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape68_out1: [i64; 4] = {
            let axes = &transpose7_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather50_out1 = shape68_out1[0] as i64;
        let unsqueeze117_out1: Tensor<4, Bool> = slice9_out1.unsqueeze_dims::<4>(&[1]);
        let constant898_out1 = -10000f32;
        let where19_out1 = div5_out1
            .mask_fill(unsqueeze117_out1.clone(), constant898_out1);
        let softmax1_out1 = burn::tensor::activation::softmax(where19_out1, 3);
        let constant899_out1 = 0f32;
        let where20_out1 = softmax1_out1
            .mask_fill(unsqueeze117_out1.clone(), constant899_out1);
        let matmul10_out1 = where20_out1.matmul(transpose7_out1);
        let transpose13_out1 = matmul10_out1.permute([0, 2, 1, 3]);
        let unsqueeze118_out1 = [gather50_out1 as i64];
        let constant902_out1: [i64; 1] = [512i64];
        let constant901_out1: [i64; 1] = [-1i64];
        let concat51_out1: [i64; 3usize] = [
            &unsqueeze118_out1[..],
            &constant901_out1[..],
            &constant902_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape34_out1 = transpose13_out1.reshape(concat51_out1);
        let linear8_out1 = self.linear8.forward(reshape34_out1);
        let add18_out1 = add14_out1.add(linear8_out1);
        (add18_out1, slice8_out1, gather42_out1, unsqueeze117_out1, concat27_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule6 {
    layernormalization3: LayerNorm,
    conv1d1: Conv1d,
    conv1d2: Conv1d,
    layernormalization4: LayerNorm,
    conv1d3: Conv1d,
    layernormalization5: LayerNorm,
    linear9: Linear,
    linear10: Linear,
    constant917: burn::module::Param<Tensor<1>>,
    layernormalization6: LayerNorm,
    layernormalization7: LayerNorm,
    linear11: Linear,
    linear12: Linear,
    constant918: burn::module::Param<Tensor<1>>,
    layernormalization8: LayerNorm,
    linear13: Linear,
    linear14: Linear,
    linear15: Linear,
    linear16: Linear,
    constant40: burn::module::Param<Tensor<2>>,
    constant41: burn::module::Param<Tensor<2>>,
    constant973: burn::module::Param<Tensor<1>>,
    linear17: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule6 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization3 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d1 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d2 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization4 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d3 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization5 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear9 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear10 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant917: 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 layernormalization6 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization7 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear11 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear12 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant918: 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 layernormalization8 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear13 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear14 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear15 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear16 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant40: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant41: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant973: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear17 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization3,
            conv1d1,
            conv1d2,
            layernormalization4,
            conv1d3,
            layernormalization5,
            linear9,
            linear10,
            constant917,
            layernormalization6,
            layernormalization7,
            linear11,
            linear12,
            constant918,
            layernormalization8,
            linear13,
            linear14,
            linear15,
            linear16,
            constant40,
            constant41,
            constant973,
            linear17,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add18_out1: Tensor<3>,
        slice8_out1: Tensor<2, Bool>,
        gather42_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3, Bool>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization3_out1 = {
            let dtype = add18_out1.clone().dtype();
            self.layernormalization3
                .forward(add18_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose14_out1 = layernormalization3_out1.permute([0, 2, 1]);
        let conv1d1_out1 = self.conv1d1.forward(transpose14_out1);
        let split_tensors = conv1d1_out1.split_with_sizes([512, 512].into(), 1);
        let [split1_out1, split1_out2] = split_tensors.try_into().unwrap();
        let sigmoid2_out1 = burn::tensor::activation::sigmoid(split1_out2);
        let mul48_out1 = split1_out1.mul(sigmoid2_out1);
        let unsqueeze119_out1: Tensor<3, Bool> = slice8_out1.unsqueeze_dims::<3>(&[1]);
        let constant904_out1 = 0f32;
        let where21_out1 = mul48_out1
            .mask_fill(unsqueeze119_out1.clone(), constant904_out1);
        let concat53_out1 = burn::tensor::Tensor::cat(
            [gather42_out1, where21_out1].into(),
            2,
        );
        let slice17_out1 = concat53_out1.clone().slice(s![.., .., - 8..]);
        let conv1d2_out1 = self.conv1d2.forward(concat53_out1);
        let transpose16_out1 = conv1d2_out1.permute([0, 2, 1]);
        let layernormalization4_out1 = {
            let dtype = transpose16_out1.dtype();
            self.layernormalization4
                .forward(transpose16_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose17_out1 = layernormalization4_out1.permute([0, 2, 1]);
        let sigmoid3_out1 = burn::tensor::activation::sigmoid(transpose17_out1.clone());
        let mul49_out1 = transpose17_out1.mul(sigmoid3_out1);
        let conv1d3_out1 = self.conv1d3.forward(mul49_out1);
        let transpose18_out1 = conv1d3_out1.permute([0, 2, 1]);
        let add19_out1 = add18_out1.add(transpose18_out1);
        let layernormalization5_out1 = {
            let dtype = add19_out1.clone().dtype();
            self.layernormalization5
                .forward(add19_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear9_out1 = self.linear9.forward(layernormalization5_out1);
        let sigmoid4_out1 = burn::tensor::activation::sigmoid(linear9_out1.clone());
        let mul50_out1 = linear9_out1.mul(sigmoid4_out1);
        let linear10_out1 = self.linear10.forward(mul50_out1);
        let constant917_out1 = self.constant917.val();
        let mul51_out1 = linear10_out1
            .mul((constant917_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add20_out1 = add19_out1.add(mul51_out1);
        let layernormalization6_out1 = {
            let dtype = add20_out1.dtype();
            self.layernormalization6
                .forward(add20_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather51_out1 = {
            let sliced = cache_last_channel.slice(s![1, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather52_out1 = {
            let sliced = cache_last_time.slice(s![1, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization7_out1 = {
            let dtype = layernormalization6_out1.clone().dtype();
            self.layernormalization7
                .forward(layernormalization6_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear11_out1 = self.linear11.forward(layernormalization7_out1);
        let sigmoid5_out1 = burn::tensor::activation::sigmoid(linear11_out1.clone());
        let mul52_out1 = linear11_out1.mul(sigmoid5_out1);
        let linear12_out1 = self.linear12.forward(mul52_out1);
        let constant918_out1 = self.constant918.val();
        let mul53_out1 = linear12_out1
            .mul((constant918_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add21_out1 = layernormalization6_out1.add(mul53_out1);
        let layernormalization8_out1 = {
            let dtype = add21_out1.clone().dtype();
            self.layernormalization8
                .forward(add21_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat54_out1 = burn::tensor::Tensor::cat(
            [gather51_out1.clone(), layernormalization8_out1.clone()].into(),
            1,
        );
        let shape69_out1: [i64; 3] = {
            let axes = &layernormalization8_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather53_out1 = shape69_out1[1] as i64;
        let unsqueeze120_out1 = [gather53_out1 as i64];
        let slice18_out1 = gather51_out1
            .slice(s![.., unsqueeze120_out1[0]..9223372036854775807, ..]);
        let unsqueeze121_out1 = [gather53_out1 as i64];
        let slice19_out1 = layernormalization8_out1
            .clone()
            .slice(s![.., 0..unsqueeze121_out1[0], ..]);
        let concat55_out1 = burn::tensor::Tensor::cat(
            [slice18_out1, slice19_out1].into(),
            1,
        );
        let gather54_out1 = shape69_out1[0] as i64;
        let linear13_out1 = self.linear13.forward(layernormalization8_out1);
        let unsqueeze122_out1 = [gather54_out1 as i64];
        let constant932_out1: [i64; 1] = [64i64];
        let constant930_out1: [i64; 1] = [-1i64];
        let constant931_out1: [i64; 1] = [8i64];
        let concat56_out1: [i64; 4usize] = [
            &unsqueeze122_out1[..],
            &constant930_out1[..],
            &constant931_out1[..],
            &constant932_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze123_out1 = [gather54_out1 as i64];
        let constant936_out1: [i64; 1] = [64i64];
        let constant934_out1: [i64; 1] = [-1i64];
        let constant935_out1: [i64; 1] = [8i64];
        let concat57_out1: [i64; 4usize] = [
            &unsqueeze123_out1[..],
            &constant934_out1[..],
            &constant935_out1[..],
            &constant936_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze124_out1 = [gather54_out1 as i64];
        let constant940_out1: [i64; 1] = [64i64];
        let constant938_out1: [i64; 1] = [-1i64];
        let constant939_out1: [i64; 1] = [8i64];
        let concat58_out1: [i64; 4usize] = [
            &unsqueeze124_out1[..],
            &constant938_out1[..],
            &constant939_out1[..],
            &constant940_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape37_out1 = linear13_out1.reshape(concat56_out1);
        let linear14_out1 = self.linear14.forward(concat54_out1.clone());
        let reshape38_out1 = linear14_out1.reshape(concat57_out1);
        let linear15_out1 = self.linear15.forward(concat54_out1);
        let reshape39_out1 = linear15_out1.reshape(concat58_out1);
        let transpose19_out1 = reshape39_out1.permute([0, 2, 1, 3]);
        let linear16_out1 = self.linear16.forward(slice5_out1);
        let reshape40_out1 = linear16_out1.reshape([1, -1, 8, 64]);
        let constant40_out1 = self.constant40.val();
        let add22_out1 = reshape37_out1
            .clone()
            .add((constant40_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose20_out1 = add22_out1.permute([0, 2, 1, 3]);
        let constant41_out1 = self.constant41.val();
        let add23_out1 = reshape37_out1
            .add((constant41_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose21_out1 = add23_out1.permute([0, 2, 1, 3]);
        let transpose22_out1 = reshape40_out1.permute([0, 2, 3, 1]);
        let matmul20_out1 = transpose21_out1.matmul(transpose22_out1);
        let shape71_out1: [i64; 4] = {
            let axes = &matmul20_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather55_out1 = shape71_out1[0] as i64;
        let gather56_out1 = shape71_out1[1] as i64;
        let gather57_out1 = shape71_out1[2] as i64;
        let gather58_out1 = shape71_out1[3] as i64;
        let pad6_out1 = matmul20_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze125_out1 = [gather55_out1 as i64];
        let unsqueeze126_out1 = [gather56_out1 as i64];
        let unsqueeze127_out1 = [gather57_out1 as i64];
        let constant955_out1: [i64; 1] = [-1i64];
        let concat60_out1: [i64; 4usize] = [
            &unsqueeze125_out1[..],
            &unsqueeze126_out1[..],
            &constant955_out1[..],
            &unsqueeze127_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape43_out1 = pad6_out1.reshape(concat60_out1);
        let slice21_out1 = reshape43_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze128_out1 = [gather55_out1 as i64];
        let unsqueeze129_out1 = [gather56_out1 as i64];
        let unsqueeze130_out1 = [gather57_out1 as i64];
        let unsqueeze131_out1 = [gather58_out1 as i64];
        let concat61_out1: [i64; 4usize] = [
            &unsqueeze128_out1[..],
            &unsqueeze129_out1[..],
            &unsqueeze130_out1[..],
            &unsqueeze131_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape44_out1 = slice21_out1.reshape(concat61_out1);
        let transpose24_out1 = reshape38_out1.permute([0, 2, 3, 1]);
        let matmul21_out1 = transpose20_out1.matmul(transpose24_out1);
        let shape75_out1: [i64; 4] = {
            let axes = &matmul21_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice22_out1: [i64; 1] = shape75_out1[3..4].try_into().unwrap();
        let squeeze2_out1 = slice22_out1[0] as i64;
        let unsqueeze132_out1 = [squeeze2_out1 as i64];
        let slice23_out1 = reshape44_out1.slice(s![.., .., .., 0..unsqueeze132_out1[0]]);
        let add24_out1 = matmul21_out1.add(slice23_out1);
        let constant973_out1 = self.constant973.val();
        let div6_out1 = add24_out1
            .div((constant973_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape76_out1: [i64; 4] = {
            let axes = &transpose19_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather59_out1 = shape76_out1[0] as i64;
        let constant975_out1 = -10000f32;
        let where22_out1 = div6_out1
            .mask_fill(unsqueeze117_out1.clone(), constant975_out1);
        let softmax2_out1 = burn::tensor::activation::softmax(where22_out1, 3);
        let constant976_out1 = 0f32;
        let where23_out1 = softmax2_out1.mask_fill(unsqueeze117_out1, constant976_out1);
        let matmul22_out1 = where23_out1.matmul(transpose19_out1);
        let transpose25_out1 = matmul22_out1.permute([0, 2, 1, 3]);
        let unsqueeze133_out1 = [gather59_out1 as i64];
        let constant979_out1: [i64; 1] = [512i64];
        let constant978_out1: [i64; 1] = [-1i64];
        let concat62_out1: [i64; 3usize] = [
            &unsqueeze133_out1[..],
            &constant978_out1[..],
            &constant979_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape45_out1 = transpose25_out1.reshape(concat62_out1);
        let linear17_out1 = self.linear17.forward(reshape45_out1);
        let add25_out1 = add21_out1.add(linear17_out1);
        (add25_out1, unsqueeze119_out1, gather52_out1, concat55_out1, slice17_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule7 {
    layernormalization9: LayerNorm,
    conv1d4: Conv1d,
    conv1d5: Conv1d,
    layernormalization10: LayerNorm,
    conv1d6: Conv1d,
    layernormalization11: LayerNorm,
    linear18: Linear,
    linear19: Linear,
    constant993: burn::module::Param<Tensor<1>>,
    layernormalization12: LayerNorm,
    layernormalization13: LayerNorm,
    linear20: Linear,
    linear21: Linear,
    constant994: burn::module::Param<Tensor<1>>,
    layernormalization14: LayerNorm,
    linear22: Linear,
    linear23: Linear,
    linear24: Linear,
    linear25: Linear,
    constant57: burn::module::Param<Tensor<2>>,
    constant58: burn::module::Param<Tensor<2>>,
    constant1049: burn::module::Param<Tensor<1>>,
    linear26: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule7 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization9 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d4 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d5 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization10 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d6 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization11 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear18 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear19 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant993: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization13 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear20 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear21 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant994: 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 layernormalization14 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear22 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear23 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear24 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear25 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant57: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant58: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1049: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear26 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization9,
            conv1d4,
            conv1d5,
            layernormalization10,
            conv1d6,
            layernormalization11,
            linear18,
            linear19,
            constant993,
            layernormalization12,
            layernormalization13,
            linear20,
            linear21,
            constant994,
            layernormalization14,
            linear22,
            linear23,
            linear24,
            linear25,
            constant57,
            constant58,
            constant1049,
            linear26,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add25_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather52_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization9_out1 = {
            let dtype = add25_out1.clone().dtype();
            self.layernormalization9
                .forward(add25_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose26_out1 = layernormalization9_out1.permute([0, 2, 1]);
        let conv1d4_out1 = self.conv1d4.forward(transpose26_out1);
        let split_tensors = conv1d4_out1.split_with_sizes([512, 512].into(), 1);
        let [split2_out1, split2_out2] = split_tensors.try_into().unwrap();
        let sigmoid6_out1 = burn::tensor::activation::sigmoid(split2_out2);
        let mul54_out1 = split2_out1.mul(sigmoid6_out1);
        let constant980_out1 = 0f32;
        let where24_out1 = mul54_out1.mask_fill(unsqueeze119_out1, constant980_out1);
        let concat64_out1 = burn::tensor::Tensor::cat(
            [gather52_out1, where24_out1].into(),
            2,
        );
        let slice25_out1 = concat64_out1.clone().slice(s![.., .., - 8..]);
        let conv1d5_out1 = self.conv1d5.forward(concat64_out1);
        let transpose28_out1 = conv1d5_out1.permute([0, 2, 1]);
        let layernormalization10_out1 = {
            let dtype = transpose28_out1.dtype();
            self.layernormalization10
                .forward(transpose28_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose29_out1 = layernormalization10_out1.permute([0, 2, 1]);
        let sigmoid7_out1 = burn::tensor::activation::sigmoid(transpose29_out1.clone());
        let mul55_out1 = transpose29_out1.mul(sigmoid7_out1);
        let conv1d6_out1 = self.conv1d6.forward(mul55_out1);
        let transpose30_out1 = conv1d6_out1.permute([0, 2, 1]);
        let add26_out1 = add25_out1.add(transpose30_out1);
        let layernormalization11_out1 = {
            let dtype = add26_out1.clone().dtype();
            self.layernormalization11
                .forward(add26_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear18_out1 = self.linear18.forward(layernormalization11_out1);
        let sigmoid8_out1 = burn::tensor::activation::sigmoid(linear18_out1.clone());
        let mul56_out1 = linear18_out1.mul(sigmoid8_out1);
        let linear19_out1 = self.linear19.forward(mul56_out1);
        let constant993_out1 = self.constant993.val();
        let mul57_out1 = linear19_out1
            .mul((constant993_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add27_out1 = add26_out1.add(mul57_out1);
        let layernormalization12_out1 = {
            let dtype = add27_out1.dtype();
            self.layernormalization12
                .forward(add27_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather60_out1 = {
            let sliced = cache_last_channel.slice(s![2, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather61_out1 = {
            let sliced = cache_last_time.slice(s![2, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization13_out1 = {
            let dtype = layernormalization12_out1.clone().dtype();
            self.layernormalization13
                .forward(
                    layernormalization12_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear20_out1 = self.linear20.forward(layernormalization13_out1);
        let sigmoid9_out1 = burn::tensor::activation::sigmoid(linear20_out1.clone());
        let mul58_out1 = linear20_out1.mul(sigmoid9_out1);
        let linear21_out1 = self.linear21.forward(mul58_out1);
        let constant994_out1 = self.constant994.val();
        let mul59_out1 = linear21_out1
            .mul((constant994_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add28_out1 = layernormalization12_out1.add(mul59_out1);
        let layernormalization14_out1 = {
            let dtype = add28_out1.clone().dtype();
            self.layernormalization14
                .forward(add28_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat65_out1 = burn::tensor::Tensor::cat(
            [gather60_out1.clone(), layernormalization14_out1.clone()].into(),
            1,
        );
        let shape77_out1: [i64; 3] = {
            let axes = &layernormalization14_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather62_out1 = shape77_out1[1] as i64;
        let unsqueeze134_out1 = [gather62_out1 as i64];
        let slice26_out1 = gather60_out1
            .slice(s![.., unsqueeze134_out1[0]..9223372036854775807, ..]);
        let unsqueeze135_out1 = [gather62_out1 as i64];
        let slice27_out1 = layernormalization14_out1
            .clone()
            .slice(s![.., 0..unsqueeze135_out1[0], ..]);
        let concat66_out1 = burn::tensor::Tensor::cat(
            [slice26_out1, slice27_out1].into(),
            1,
        );
        let gather63_out1 = shape77_out1[0] as i64;
        let linear22_out1 = self.linear22.forward(layernormalization14_out1);
        let unsqueeze136_out1 = [gather63_out1 as i64];
        let constant1008_out1: [i64; 1] = [64i64];
        let constant1006_out1: [i64; 1] = [-1i64];
        let constant1007_out1: [i64; 1] = [8i64];
        let concat67_out1: [i64; 4usize] = [
            &unsqueeze136_out1[..],
            &constant1006_out1[..],
            &constant1007_out1[..],
            &constant1008_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze137_out1 = [gather63_out1 as i64];
        let constant1012_out1: [i64; 1] = [64i64];
        let constant1010_out1: [i64; 1] = [-1i64];
        let constant1011_out1: [i64; 1] = [8i64];
        let concat68_out1: [i64; 4usize] = [
            &unsqueeze137_out1[..],
            &constant1010_out1[..],
            &constant1011_out1[..],
            &constant1012_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze138_out1 = [gather63_out1 as i64];
        let constant1016_out1: [i64; 1] = [64i64];
        let constant1014_out1: [i64; 1] = [-1i64];
        let constant1015_out1: [i64; 1] = [8i64];
        let concat69_out1: [i64; 4usize] = [
            &unsqueeze138_out1[..],
            &constant1014_out1[..],
            &constant1015_out1[..],
            &constant1016_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape48_out1 = linear22_out1.reshape(concat67_out1);
        let linear23_out1 = self.linear23.forward(concat65_out1.clone());
        let reshape49_out1 = linear23_out1.reshape(concat68_out1);
        let linear24_out1 = self.linear24.forward(concat65_out1);
        let reshape50_out1 = linear24_out1.reshape(concat69_out1);
        let transpose31_out1 = reshape50_out1.permute([0, 2, 1, 3]);
        let linear25_out1 = self.linear25.forward(slice5_out1);
        let reshape51_out1 = linear25_out1.reshape([1, -1, 8, 64]);
        let constant57_out1 = self.constant57.val();
        let add29_out1 = reshape48_out1
            .clone()
            .add((constant57_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose32_out1 = add29_out1.permute([0, 2, 1, 3]);
        let constant58_out1 = self.constant58.val();
        let add30_out1 = reshape48_out1
            .add((constant58_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose33_out1 = add30_out1.permute([0, 2, 1, 3]);
        let transpose34_out1 = reshape51_out1.permute([0, 2, 3, 1]);
        let matmul32_out1 = transpose33_out1.matmul(transpose34_out1);
        let shape79_out1: [i64; 4] = {
            let axes = &matmul32_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather64_out1 = shape79_out1[0] as i64;
        let gather65_out1 = shape79_out1[1] as i64;
        let gather66_out1 = shape79_out1[2] as i64;
        let gather67_out1 = shape79_out1[3] as i64;
        let pad8_out1 = matmul32_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze139_out1 = [gather64_out1 as i64];
        let unsqueeze140_out1 = [gather65_out1 as i64];
        let unsqueeze141_out1 = [gather66_out1 as i64];
        let constant1031_out1: [i64; 1] = [-1i64];
        let concat71_out1: [i64; 4usize] = [
            &unsqueeze139_out1[..],
            &unsqueeze140_out1[..],
            &constant1031_out1[..],
            &unsqueeze141_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape54_out1 = pad8_out1.reshape(concat71_out1);
        let slice29_out1 = reshape54_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze142_out1 = [gather64_out1 as i64];
        let unsqueeze143_out1 = [gather65_out1 as i64];
        let unsqueeze144_out1 = [gather66_out1 as i64];
        let unsqueeze145_out1 = [gather67_out1 as i64];
        let concat72_out1: [i64; 4usize] = [
            &unsqueeze142_out1[..],
            &unsqueeze143_out1[..],
            &unsqueeze144_out1[..],
            &unsqueeze145_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape55_out1 = slice29_out1.reshape(concat72_out1);
        let transpose36_out1 = reshape49_out1.permute([0, 2, 3, 1]);
        let matmul33_out1 = transpose32_out1.matmul(transpose36_out1);
        let shape83_out1: [i64; 4] = {
            let axes = &matmul33_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice30_out1: [i64; 1] = shape83_out1[3..4].try_into().unwrap();
        let squeeze3_out1 = slice30_out1[0] as i64;
        let unsqueeze146_out1 = [squeeze3_out1 as i64];
        let slice31_out1 = reshape55_out1.slice(s![.., .., .., 0..unsqueeze146_out1[0]]);
        let add31_out1 = matmul33_out1.add(slice31_out1);
        let constant1049_out1 = self.constant1049.val();
        let div7_out1 = add31_out1
            .div((constant1049_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape84_out1: [i64; 4] = {
            let axes = &transpose31_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather68_out1 = shape84_out1[0] as i64;
        let constant1051_out1 = -10000f32;
        let where25_out1 = div7_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1051_out1);
        let softmax3_out1 = burn::tensor::activation::softmax(where25_out1, 3);
        let constant1052_out1 = 0f32;
        let where26_out1 = softmax3_out1.mask_fill(unsqueeze117_out1, constant1052_out1);
        let matmul34_out1 = where26_out1.matmul(transpose31_out1);
        let transpose37_out1 = matmul34_out1.permute([0, 2, 1, 3]);
        let unsqueeze147_out1 = [gather68_out1 as i64];
        let constant1055_out1: [i64; 1] = [512i64];
        let constant1054_out1: [i64; 1] = [-1i64];
        let concat73_out1: [i64; 3usize] = [
            &unsqueeze147_out1[..],
            &constant1054_out1[..],
            &constant1055_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape56_out1 = transpose37_out1.reshape(concat73_out1);
        let linear26_out1 = self.linear26.forward(reshape56_out1);
        let add32_out1 = add28_out1.add(linear26_out1);
        (add32_out1, gather61_out1, concat66_out1, slice25_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule8 {
    layernormalization15: LayerNorm,
    conv1d7: Conv1d,
    conv1d8: Conv1d,
    layernormalization16: LayerNorm,
    conv1d9: Conv1d,
    layernormalization17: LayerNorm,
    linear27: Linear,
    linear28: Linear,
    constant1069: burn::module::Param<Tensor<1>>,
    layernormalization18: LayerNorm,
    layernormalization19: LayerNorm,
    linear29: Linear,
    linear30: Linear,
    constant1070: burn::module::Param<Tensor<1>>,
    layernormalization20: LayerNorm,
    linear31: Linear,
    linear32: Linear,
    linear33: Linear,
    linear34: Linear,
    constant74: burn::module::Param<Tensor<2>>,
    constant75: burn::module::Param<Tensor<2>>,
    constant1125: burn::module::Param<Tensor<1>>,
    linear35: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule8 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization15 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d7 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d8 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization16 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d9 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization17 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear27 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear28 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1069: 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 layernormalization18 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization19 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear29 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear30 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1070: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear31 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear32 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear33 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear34 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant74: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant75: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1125: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear35 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization15,
            conv1d7,
            conv1d8,
            layernormalization16,
            conv1d9,
            layernormalization17,
            linear27,
            linear28,
            constant1069,
            layernormalization18,
            layernormalization19,
            linear29,
            linear30,
            constant1070,
            layernormalization20,
            linear31,
            linear32,
            linear33,
            linear34,
            constant74,
            constant75,
            constant1125,
            linear35,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add32_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather61_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization15_out1 = {
            let dtype = add32_out1.clone().dtype();
            self.layernormalization15
                .forward(add32_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose38_out1 = layernormalization15_out1.permute([0, 2, 1]);
        let conv1d7_out1 = self.conv1d7.forward(transpose38_out1);
        let split_tensors = conv1d7_out1.split_with_sizes([512, 512].into(), 1);
        let [split3_out1, split3_out2] = split_tensors.try_into().unwrap();
        let sigmoid10_out1 = burn::tensor::activation::sigmoid(split3_out2);
        let mul60_out1 = split3_out1.mul(sigmoid10_out1);
        let constant1056_out1 = 0f32;
        let where27_out1 = mul60_out1.mask_fill(unsqueeze119_out1, constant1056_out1);
        let concat75_out1 = burn::tensor::Tensor::cat(
            [gather61_out1, where27_out1].into(),
            2,
        );
        let slice33_out1 = concat75_out1.clone().slice(s![.., .., - 8..]);
        let conv1d8_out1 = self.conv1d8.forward(concat75_out1);
        let transpose40_out1 = conv1d8_out1.permute([0, 2, 1]);
        let layernormalization16_out1 = {
            let dtype = transpose40_out1.dtype();
            self.layernormalization16
                .forward(transpose40_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose41_out1 = layernormalization16_out1.permute([0, 2, 1]);
        let sigmoid11_out1 = burn::tensor::activation::sigmoid(transpose41_out1.clone());
        let mul61_out1 = transpose41_out1.mul(sigmoid11_out1);
        let conv1d9_out1 = self.conv1d9.forward(mul61_out1);
        let transpose42_out1 = conv1d9_out1.permute([0, 2, 1]);
        let add33_out1 = add32_out1.add(transpose42_out1);
        let layernormalization17_out1 = {
            let dtype = add33_out1.clone().dtype();
            self.layernormalization17
                .forward(add33_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear27_out1 = self.linear27.forward(layernormalization17_out1);
        let sigmoid12_out1 = burn::tensor::activation::sigmoid(linear27_out1.clone());
        let mul62_out1 = linear27_out1.mul(sigmoid12_out1);
        let linear28_out1 = self.linear28.forward(mul62_out1);
        let constant1069_out1 = self.constant1069.val();
        let mul63_out1 = linear28_out1
            .mul((constant1069_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add34_out1 = add33_out1.add(mul63_out1);
        let layernormalization18_out1 = {
            let dtype = add34_out1.dtype();
            self.layernormalization18
                .forward(add34_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather69_out1 = {
            let sliced = cache_last_channel.slice(s![3, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather70_out1 = {
            let sliced = cache_last_time.slice(s![3, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization19_out1 = {
            let dtype = layernormalization18_out1.clone().dtype();
            self.layernormalization19
                .forward(
                    layernormalization18_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear29_out1 = self.linear29.forward(layernormalization19_out1);
        let sigmoid13_out1 = burn::tensor::activation::sigmoid(linear29_out1.clone());
        let mul64_out1 = linear29_out1.mul(sigmoid13_out1);
        let linear30_out1 = self.linear30.forward(mul64_out1);
        let constant1070_out1 = self.constant1070.val();
        let mul65_out1 = linear30_out1
            .mul((constant1070_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add35_out1 = layernormalization18_out1.add(mul65_out1);
        let layernormalization20_out1 = {
            let dtype = add35_out1.clone().dtype();
            self.layernormalization20
                .forward(add35_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat76_out1 = burn::tensor::Tensor::cat(
            [gather69_out1.clone(), layernormalization20_out1.clone()].into(),
            1,
        );
        let shape85_out1: [i64; 3] = {
            let axes = &layernormalization20_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather71_out1 = shape85_out1[1] as i64;
        let unsqueeze148_out1 = [gather71_out1 as i64];
        let slice34_out1 = gather69_out1
            .slice(s![.., unsqueeze148_out1[0]..9223372036854775807, ..]);
        let unsqueeze149_out1 = [gather71_out1 as i64];
        let slice35_out1 = layernormalization20_out1
            .clone()
            .slice(s![.., 0..unsqueeze149_out1[0], ..]);
        let concat77_out1 = burn::tensor::Tensor::cat(
            [slice34_out1, slice35_out1].into(),
            1,
        );
        let gather72_out1 = shape85_out1[0] as i64;
        let linear31_out1 = self.linear31.forward(layernormalization20_out1);
        let unsqueeze150_out1 = [gather72_out1 as i64];
        let constant1084_out1: [i64; 1] = [64i64];
        let constant1082_out1: [i64; 1] = [-1i64];
        let constant1083_out1: [i64; 1] = [8i64];
        let concat78_out1: [i64; 4usize] = [
            &unsqueeze150_out1[..],
            &constant1082_out1[..],
            &constant1083_out1[..],
            &constant1084_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze151_out1 = [gather72_out1 as i64];
        let constant1088_out1: [i64; 1] = [64i64];
        let constant1086_out1: [i64; 1] = [-1i64];
        let constant1087_out1: [i64; 1] = [8i64];
        let concat79_out1: [i64; 4usize] = [
            &unsqueeze151_out1[..],
            &constant1086_out1[..],
            &constant1087_out1[..],
            &constant1088_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze152_out1 = [gather72_out1 as i64];
        let constant1092_out1: [i64; 1] = [64i64];
        let constant1090_out1: [i64; 1] = [-1i64];
        let constant1091_out1: [i64; 1] = [8i64];
        let concat80_out1: [i64; 4usize] = [
            &unsqueeze152_out1[..],
            &constant1090_out1[..],
            &constant1091_out1[..],
            &constant1092_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape59_out1 = linear31_out1.reshape(concat78_out1);
        let linear32_out1 = self.linear32.forward(concat76_out1.clone());
        let reshape60_out1 = linear32_out1.reshape(concat79_out1);
        let linear33_out1 = self.linear33.forward(concat76_out1);
        let reshape61_out1 = linear33_out1.reshape(concat80_out1);
        let transpose43_out1 = reshape61_out1.permute([0, 2, 1, 3]);
        let linear34_out1 = self.linear34.forward(slice5_out1);
        let reshape62_out1 = linear34_out1.reshape([1, -1, 8, 64]);
        let constant74_out1 = self.constant74.val();
        let add36_out1 = reshape59_out1
            .clone()
            .add((constant74_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose44_out1 = add36_out1.permute([0, 2, 1, 3]);
        let constant75_out1 = self.constant75.val();
        let add37_out1 = reshape59_out1
            .add((constant75_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose45_out1 = add37_out1.permute([0, 2, 1, 3]);
        let transpose46_out1 = reshape62_out1.permute([0, 2, 3, 1]);
        let matmul44_out1 = transpose45_out1.matmul(transpose46_out1);
        let shape87_out1: [i64; 4] = {
            let axes = &matmul44_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather73_out1 = shape87_out1[0] as i64;
        let gather74_out1 = shape87_out1[1] as i64;
        let gather75_out1 = shape87_out1[2] as i64;
        let gather76_out1 = shape87_out1[3] as i64;
        let pad10_out1 = matmul44_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze153_out1 = [gather73_out1 as i64];
        let unsqueeze154_out1 = [gather74_out1 as i64];
        let unsqueeze155_out1 = [gather75_out1 as i64];
        let constant1107_out1: [i64; 1] = [-1i64];
        let concat82_out1: [i64; 4usize] = [
            &unsqueeze153_out1[..],
            &unsqueeze154_out1[..],
            &constant1107_out1[..],
            &unsqueeze155_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape65_out1 = pad10_out1.reshape(concat82_out1);
        let slice37_out1 = reshape65_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze156_out1 = [gather73_out1 as i64];
        let unsqueeze157_out1 = [gather74_out1 as i64];
        let unsqueeze158_out1 = [gather75_out1 as i64];
        let unsqueeze159_out1 = [gather76_out1 as i64];
        let concat83_out1: [i64; 4usize] = [
            &unsqueeze156_out1[..],
            &unsqueeze157_out1[..],
            &unsqueeze158_out1[..],
            &unsqueeze159_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape66_out1 = slice37_out1.reshape(concat83_out1);
        let transpose48_out1 = reshape60_out1.permute([0, 2, 3, 1]);
        let matmul45_out1 = transpose44_out1.matmul(transpose48_out1);
        let shape91_out1: [i64; 4] = {
            let axes = &matmul45_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice38_out1: [i64; 1] = shape91_out1[3..4].try_into().unwrap();
        let squeeze4_out1 = slice38_out1[0] as i64;
        let unsqueeze160_out1 = [squeeze4_out1 as i64];
        let slice39_out1 = reshape66_out1.slice(s![.., .., .., 0..unsqueeze160_out1[0]]);
        let add38_out1 = matmul45_out1.add(slice39_out1);
        let constant1125_out1 = self.constant1125.val();
        let div8_out1 = add38_out1
            .div((constant1125_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape92_out1: [i64; 4] = {
            let axes = &transpose43_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather77_out1 = shape92_out1[0] as i64;
        let constant1127_out1 = -10000f32;
        let where28_out1 = div8_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1127_out1);
        let softmax4_out1 = burn::tensor::activation::softmax(where28_out1, 3);
        let constant1128_out1 = 0f32;
        let where29_out1 = softmax4_out1.mask_fill(unsqueeze117_out1, constant1128_out1);
        let matmul46_out1 = where29_out1.matmul(transpose43_out1);
        let transpose49_out1 = matmul46_out1.permute([0, 2, 1, 3]);
        let unsqueeze161_out1 = [gather77_out1 as i64];
        let constant1131_out1: [i64; 1] = [512i64];
        let constant1130_out1: [i64; 1] = [-1i64];
        let concat84_out1: [i64; 3usize] = [
            &unsqueeze161_out1[..],
            &constant1130_out1[..],
            &constant1131_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape67_out1 = transpose49_out1.reshape(concat84_out1);
        let linear35_out1 = self.linear35.forward(reshape67_out1);
        let add39_out1 = add35_out1.add(linear35_out1);
        (add39_out1, gather70_out1, concat77_out1, slice33_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule9 {
    layernormalization21: LayerNorm,
    conv1d10: Conv1d,
    conv1d11: Conv1d,
    layernormalization22: LayerNorm,
    conv1d12: Conv1d,
    layernormalization23: LayerNorm,
    linear36: Linear,
    linear37: Linear,
    constant1145: burn::module::Param<Tensor<1>>,
    layernormalization24: LayerNorm,
    layernormalization25: LayerNorm,
    linear38: Linear,
    linear39: Linear,
    constant1146: burn::module::Param<Tensor<1>>,
    layernormalization26: LayerNorm,
    linear40: Linear,
    linear41: Linear,
    linear42: Linear,
    linear43: Linear,
    constant91: burn::module::Param<Tensor<2>>,
    constant92: burn::module::Param<Tensor<2>>,
    constant1201: burn::module::Param<Tensor<1>>,
    linear44: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule9 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization21 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d10 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d11 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization22 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d12 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization23 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear36 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear37 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1145: 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 layernormalization24 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization25 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear38 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear39 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1146: 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 layernormalization26 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear40 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear41 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear42 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear43 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant91: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant92: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1201: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear44 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization21,
            conv1d10,
            conv1d11,
            layernormalization22,
            conv1d12,
            layernormalization23,
            linear36,
            linear37,
            constant1145,
            layernormalization24,
            layernormalization25,
            linear38,
            linear39,
            constant1146,
            layernormalization26,
            linear40,
            linear41,
            linear42,
            linear43,
            constant91,
            constant92,
            constant1201,
            linear44,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add39_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather70_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization21_out1 = {
            let dtype = add39_out1.clone().dtype();
            self.layernormalization21
                .forward(add39_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose50_out1 = layernormalization21_out1.permute([0, 2, 1]);
        let conv1d10_out1 = self.conv1d10.forward(transpose50_out1);
        let split_tensors = conv1d10_out1.split_with_sizes([512, 512].into(), 1);
        let [split4_out1, split4_out2] = split_tensors.try_into().unwrap();
        let sigmoid14_out1 = burn::tensor::activation::sigmoid(split4_out2);
        let mul66_out1 = split4_out1.mul(sigmoid14_out1);
        let constant1132_out1 = 0f32;
        let where30_out1 = mul66_out1.mask_fill(unsqueeze119_out1, constant1132_out1);
        let concat86_out1 = burn::tensor::Tensor::cat(
            [gather70_out1, where30_out1].into(),
            2,
        );
        let slice41_out1 = concat86_out1.clone().slice(s![.., .., - 8..]);
        let conv1d11_out1 = self.conv1d11.forward(concat86_out1);
        let transpose52_out1 = conv1d11_out1.permute([0, 2, 1]);
        let layernormalization22_out1 = {
            let dtype = transpose52_out1.dtype();
            self.layernormalization22
                .forward(transpose52_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose53_out1 = layernormalization22_out1.permute([0, 2, 1]);
        let sigmoid15_out1 = burn::tensor::activation::sigmoid(transpose53_out1.clone());
        let mul67_out1 = transpose53_out1.mul(sigmoid15_out1);
        let conv1d12_out1 = self.conv1d12.forward(mul67_out1);
        let transpose54_out1 = conv1d12_out1.permute([0, 2, 1]);
        let add40_out1 = add39_out1.add(transpose54_out1);
        let layernormalization23_out1 = {
            let dtype = add40_out1.clone().dtype();
            self.layernormalization23
                .forward(add40_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear36_out1 = self.linear36.forward(layernormalization23_out1);
        let sigmoid16_out1 = burn::tensor::activation::sigmoid(linear36_out1.clone());
        let mul68_out1 = linear36_out1.mul(sigmoid16_out1);
        let linear37_out1 = self.linear37.forward(mul68_out1);
        let constant1145_out1 = self.constant1145.val();
        let mul69_out1 = linear37_out1
            .mul((constant1145_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add41_out1 = add40_out1.add(mul69_out1);
        let layernormalization24_out1 = {
            let dtype = add41_out1.dtype();
            self.layernormalization24
                .forward(add41_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather78_out1 = {
            let sliced = cache_last_channel.slice(s![4, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather79_out1 = {
            let sliced = cache_last_time.slice(s![4, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization25_out1 = {
            let dtype = layernormalization24_out1.clone().dtype();
            self.layernormalization25
                .forward(
                    layernormalization24_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear38_out1 = self.linear38.forward(layernormalization25_out1);
        let sigmoid17_out1 = burn::tensor::activation::sigmoid(linear38_out1.clone());
        let mul70_out1 = linear38_out1.mul(sigmoid17_out1);
        let linear39_out1 = self.linear39.forward(mul70_out1);
        let constant1146_out1 = self.constant1146.val();
        let mul71_out1 = linear39_out1
            .mul((constant1146_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add42_out1 = layernormalization24_out1.add(mul71_out1);
        let layernormalization26_out1 = {
            let dtype = add42_out1.clone().dtype();
            self.layernormalization26
                .forward(add42_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat87_out1 = burn::tensor::Tensor::cat(
            [gather78_out1.clone(), layernormalization26_out1.clone()].into(),
            1,
        );
        let shape93_out1: [i64; 3] = {
            let axes = &layernormalization26_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather80_out1 = shape93_out1[1] as i64;
        let unsqueeze162_out1 = [gather80_out1 as i64];
        let slice42_out1 = gather78_out1
            .slice(s![.., unsqueeze162_out1[0]..9223372036854775807, ..]);
        let unsqueeze163_out1 = [gather80_out1 as i64];
        let slice43_out1 = layernormalization26_out1
            .clone()
            .slice(s![.., 0..unsqueeze163_out1[0], ..]);
        let concat88_out1 = burn::tensor::Tensor::cat(
            [slice42_out1, slice43_out1].into(),
            1,
        );
        let gather81_out1 = shape93_out1[0] as i64;
        let linear40_out1 = self.linear40.forward(layernormalization26_out1);
        let unsqueeze164_out1 = [gather81_out1 as i64];
        let constant1160_out1: [i64; 1] = [64i64];
        let constant1158_out1: [i64; 1] = [-1i64];
        let constant1159_out1: [i64; 1] = [8i64];
        let concat89_out1: [i64; 4usize] = [
            &unsqueeze164_out1[..],
            &constant1158_out1[..],
            &constant1159_out1[..],
            &constant1160_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze165_out1 = [gather81_out1 as i64];
        let constant1164_out1: [i64; 1] = [64i64];
        let constant1162_out1: [i64; 1] = [-1i64];
        let constant1163_out1: [i64; 1] = [8i64];
        let concat90_out1: [i64; 4usize] = [
            &unsqueeze165_out1[..],
            &constant1162_out1[..],
            &constant1163_out1[..],
            &constant1164_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze166_out1 = [gather81_out1 as i64];
        let constant1168_out1: [i64; 1] = [64i64];
        let constant1166_out1: [i64; 1] = [-1i64];
        let constant1167_out1: [i64; 1] = [8i64];
        let concat91_out1: [i64; 4usize] = [
            &unsqueeze166_out1[..],
            &constant1166_out1[..],
            &constant1167_out1[..],
            &constant1168_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape70_out1 = linear40_out1.reshape(concat89_out1);
        let linear41_out1 = self.linear41.forward(concat87_out1.clone());
        let reshape71_out1 = linear41_out1.reshape(concat90_out1);
        let linear42_out1 = self.linear42.forward(concat87_out1);
        let reshape72_out1 = linear42_out1.reshape(concat91_out1);
        let transpose55_out1 = reshape72_out1.permute([0, 2, 1, 3]);
        let linear43_out1 = self.linear43.forward(slice5_out1);
        let reshape73_out1 = linear43_out1.reshape([1, -1, 8, 64]);
        let constant91_out1 = self.constant91.val();
        let add43_out1 = reshape70_out1
            .clone()
            .add((constant91_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose56_out1 = add43_out1.permute([0, 2, 1, 3]);
        let constant92_out1 = self.constant92.val();
        let add44_out1 = reshape70_out1
            .add((constant92_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose57_out1 = add44_out1.permute([0, 2, 1, 3]);
        let transpose58_out1 = reshape73_out1.permute([0, 2, 3, 1]);
        let matmul56_out1 = transpose57_out1.matmul(transpose58_out1);
        let shape95_out1: [i64; 4] = {
            let axes = &matmul56_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather82_out1 = shape95_out1[0] as i64;
        let gather83_out1 = shape95_out1[1] as i64;
        let gather84_out1 = shape95_out1[2] as i64;
        let gather85_out1 = shape95_out1[3] as i64;
        let pad12_out1 = matmul56_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze167_out1 = [gather82_out1 as i64];
        let unsqueeze168_out1 = [gather83_out1 as i64];
        let unsqueeze169_out1 = [gather84_out1 as i64];
        let constant1183_out1: [i64; 1] = [-1i64];
        let concat93_out1: [i64; 4usize] = [
            &unsqueeze167_out1[..],
            &unsqueeze168_out1[..],
            &constant1183_out1[..],
            &unsqueeze169_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape76_out1 = pad12_out1.reshape(concat93_out1);
        let slice45_out1 = reshape76_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze170_out1 = [gather82_out1 as i64];
        let unsqueeze171_out1 = [gather83_out1 as i64];
        let unsqueeze172_out1 = [gather84_out1 as i64];
        let unsqueeze173_out1 = [gather85_out1 as i64];
        let concat94_out1: [i64; 4usize] = [
            &unsqueeze170_out1[..],
            &unsqueeze171_out1[..],
            &unsqueeze172_out1[..],
            &unsqueeze173_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape77_out1 = slice45_out1.reshape(concat94_out1);
        let transpose60_out1 = reshape71_out1.permute([0, 2, 3, 1]);
        let matmul57_out1 = transpose56_out1.matmul(transpose60_out1);
        let shape99_out1: [i64; 4] = {
            let axes = &matmul57_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice46_out1: [i64; 1] = shape99_out1[3..4].try_into().unwrap();
        let squeeze5_out1 = slice46_out1[0] as i64;
        let unsqueeze174_out1 = [squeeze5_out1 as i64];
        let slice47_out1 = reshape77_out1.slice(s![.., .., .., 0..unsqueeze174_out1[0]]);
        let add45_out1 = matmul57_out1.add(slice47_out1);
        let constant1201_out1 = self.constant1201.val();
        let div9_out1 = add45_out1
            .div((constant1201_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape100_out1: [i64; 4] = {
            let axes = &transpose55_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather86_out1 = shape100_out1[0] as i64;
        let constant1203_out1 = -10000f32;
        let where31_out1 = div9_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1203_out1);
        let softmax5_out1 = burn::tensor::activation::softmax(where31_out1, 3);
        let constant1204_out1 = 0f32;
        let where32_out1 = softmax5_out1.mask_fill(unsqueeze117_out1, constant1204_out1);
        let matmul58_out1 = where32_out1.matmul(transpose55_out1);
        let transpose61_out1 = matmul58_out1.permute([0, 2, 1, 3]);
        let unsqueeze175_out1 = [gather86_out1 as i64];
        let constant1207_out1: [i64; 1] = [512i64];
        let constant1206_out1: [i64; 1] = [-1i64];
        let concat95_out1: [i64; 3usize] = [
            &unsqueeze175_out1[..],
            &constant1206_out1[..],
            &constant1207_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape78_out1 = transpose61_out1.reshape(concat95_out1);
        let linear44_out1 = self.linear44.forward(reshape78_out1);
        let add46_out1 = add42_out1.add(linear44_out1);
        (add46_out1, gather79_out1, concat88_out1, slice41_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule10 {
    layernormalization27: LayerNorm,
    conv1d13: Conv1d,
    conv1d14: Conv1d,
    layernormalization28: LayerNorm,
    conv1d15: Conv1d,
    layernormalization29: LayerNorm,
    linear45: Linear,
    linear46: Linear,
    constant1221: burn::module::Param<Tensor<1>>,
    layernormalization30: LayerNorm,
    layernormalization31: LayerNorm,
    linear47: Linear,
    linear48: Linear,
    constant1223: burn::module::Param<Tensor<1>>,
    layernormalization32: LayerNorm,
    linear49: Linear,
    linear50: Linear,
    linear51: Linear,
    linear52: Linear,
    constant108: burn::module::Param<Tensor<2>>,
    constant109: burn::module::Param<Tensor<2>>,
    constant1278: burn::module::Param<Tensor<1>>,
    linear53: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule10 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization27 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d13 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d14 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization28 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d15 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization29 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear45 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear46 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1221: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization31 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear47 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear48 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1223: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear49 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear50 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear51 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear52 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant108: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant109: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1278: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear53 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization27,
            conv1d13,
            conv1d14,
            layernormalization28,
            conv1d15,
            layernormalization29,
            linear45,
            linear46,
            constant1221,
            layernormalization30,
            layernormalization31,
            linear47,
            linear48,
            constant1223,
            layernormalization32,
            linear49,
            linear50,
            linear51,
            linear52,
            constant108,
            constant109,
            constant1278,
            linear53,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add46_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather79_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization27_out1 = {
            let dtype = add46_out1.clone().dtype();
            self.layernormalization27
                .forward(add46_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose62_out1 = layernormalization27_out1.permute([0, 2, 1]);
        let conv1d13_out1 = self.conv1d13.forward(transpose62_out1);
        let split_tensors = conv1d13_out1.split_with_sizes([512, 512].into(), 1);
        let [split5_out1, split5_out2] = split_tensors.try_into().unwrap();
        let sigmoid18_out1 = burn::tensor::activation::sigmoid(split5_out2);
        let mul72_out1 = split5_out1.mul(sigmoid18_out1);
        let constant1208_out1 = 0f32;
        let where33_out1 = mul72_out1.mask_fill(unsqueeze119_out1, constant1208_out1);
        let concat97_out1 = burn::tensor::Tensor::cat(
            [gather79_out1, where33_out1].into(),
            2,
        );
        let slice49_out1 = concat97_out1.clone().slice(s![.., .., - 8..]);
        let conv1d14_out1 = self.conv1d14.forward(concat97_out1);
        let transpose64_out1 = conv1d14_out1.permute([0, 2, 1]);
        let layernormalization28_out1 = {
            let dtype = transpose64_out1.dtype();
            self.layernormalization28
                .forward(transpose64_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose65_out1 = layernormalization28_out1.permute([0, 2, 1]);
        let sigmoid19_out1 = burn::tensor::activation::sigmoid(transpose65_out1.clone());
        let mul73_out1 = transpose65_out1.mul(sigmoid19_out1);
        let conv1d15_out1 = self.conv1d15.forward(mul73_out1);
        let transpose66_out1 = conv1d15_out1.permute([0, 2, 1]);
        let add47_out1 = add46_out1.add(transpose66_out1);
        let layernormalization29_out1 = {
            let dtype = add47_out1.clone().dtype();
            self.layernormalization29
                .forward(add47_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear45_out1 = self.linear45.forward(layernormalization29_out1);
        let sigmoid20_out1 = burn::tensor::activation::sigmoid(linear45_out1.clone());
        let mul74_out1 = linear45_out1.mul(sigmoid20_out1);
        let linear46_out1 = self.linear46.forward(mul74_out1);
        let constant1221_out1 = self.constant1221.val();
        let mul75_out1 = linear46_out1
            .mul((constant1221_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add48_out1 = add47_out1.add(mul75_out1);
        let layernormalization30_out1 = {
            let dtype = add48_out1.dtype();
            self.layernormalization30
                .forward(add48_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather87_out1 = {
            let sliced = cache_last_channel.slice(s![5, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather88_out1 = {
            let sliced = cache_last_time.slice(s![5, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization31_out1 = {
            let dtype = layernormalization30_out1.clone().dtype();
            self.layernormalization31
                .forward(
                    layernormalization30_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear47_out1 = self.linear47.forward(layernormalization31_out1);
        let sigmoid21_out1 = burn::tensor::activation::sigmoid(linear47_out1.clone());
        let mul76_out1 = linear47_out1.mul(sigmoid21_out1);
        let linear48_out1 = self.linear48.forward(mul76_out1);
        let constant1223_out1 = self.constant1223.val();
        let mul77_out1 = linear48_out1
            .mul((constant1223_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add49_out1 = layernormalization30_out1.add(mul77_out1);
        let layernormalization32_out1 = {
            let dtype = add49_out1.clone().dtype();
            self.layernormalization32
                .forward(add49_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat98_out1 = burn::tensor::Tensor::cat(
            [gather87_out1.clone(), layernormalization32_out1.clone()].into(),
            1,
        );
        let shape101_out1: [i64; 3] = {
            let axes = &layernormalization32_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather89_out1 = shape101_out1[1] as i64;
        let unsqueeze176_out1 = [gather89_out1 as i64];
        let slice50_out1 = gather87_out1
            .slice(s![.., unsqueeze176_out1[0]..9223372036854775807, ..]);
        let unsqueeze177_out1 = [gather89_out1 as i64];
        let slice51_out1 = layernormalization32_out1
            .clone()
            .slice(s![.., 0..unsqueeze177_out1[0], ..]);
        let concat99_out1 = burn::tensor::Tensor::cat(
            [slice50_out1, slice51_out1].into(),
            1,
        );
        let gather90_out1 = shape101_out1[0] as i64;
        let linear49_out1 = self.linear49.forward(layernormalization32_out1);
        let unsqueeze178_out1 = [gather90_out1 as i64];
        let constant1237_out1: [i64; 1] = [64i64];
        let constant1235_out1: [i64; 1] = [-1i64];
        let constant1236_out1: [i64; 1] = [8i64];
        let concat100_out1: [i64; 4usize] = [
            &unsqueeze178_out1[..],
            &constant1235_out1[..],
            &constant1236_out1[..],
            &constant1237_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze179_out1 = [gather90_out1 as i64];
        let constant1241_out1: [i64; 1] = [64i64];
        let constant1239_out1: [i64; 1] = [-1i64];
        let constant1240_out1: [i64; 1] = [8i64];
        let concat101_out1: [i64; 4usize] = [
            &unsqueeze179_out1[..],
            &constant1239_out1[..],
            &constant1240_out1[..],
            &constant1241_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze180_out1 = [gather90_out1 as i64];
        let constant1245_out1: [i64; 1] = [64i64];
        let constant1243_out1: [i64; 1] = [-1i64];
        let constant1244_out1: [i64; 1] = [8i64];
        let concat102_out1: [i64; 4usize] = [
            &unsqueeze180_out1[..],
            &constant1243_out1[..],
            &constant1244_out1[..],
            &constant1245_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape81_out1 = linear49_out1.reshape(concat100_out1);
        let linear50_out1 = self.linear50.forward(concat98_out1.clone());
        let reshape82_out1 = linear50_out1.reshape(concat101_out1);
        let linear51_out1 = self.linear51.forward(concat98_out1);
        let reshape83_out1 = linear51_out1.reshape(concat102_out1);
        let transpose67_out1 = reshape83_out1.permute([0, 2, 1, 3]);
        let linear52_out1 = self.linear52.forward(slice5_out1);
        let reshape84_out1 = linear52_out1.reshape([1, -1, 8, 64]);
        let constant108_out1 = self.constant108.val();
        let add50_out1 = reshape81_out1
            .clone()
            .add((constant108_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose68_out1 = add50_out1.permute([0, 2, 1, 3]);
        let constant109_out1 = self.constant109.val();
        let add51_out1 = reshape81_out1
            .add((constant109_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose69_out1 = add51_out1.permute([0, 2, 1, 3]);
        let transpose70_out1 = reshape84_out1.permute([0, 2, 3, 1]);
        let matmul68_out1 = transpose69_out1.matmul(transpose70_out1);
        let shape103_out1: [i64; 4] = {
            let axes = &matmul68_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather91_out1 = shape103_out1[0] as i64;
        let gather92_out1 = shape103_out1[1] as i64;
        let gather93_out1 = shape103_out1[2] as i64;
        let gather94_out1 = shape103_out1[3] as i64;
        let pad14_out1 = matmul68_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze181_out1 = [gather91_out1 as i64];
        let unsqueeze182_out1 = [gather92_out1 as i64];
        let unsqueeze183_out1 = [gather93_out1 as i64];
        let constant1260_out1: [i64; 1] = [-1i64];
        let concat104_out1: [i64; 4usize] = [
            &unsqueeze181_out1[..],
            &unsqueeze182_out1[..],
            &constant1260_out1[..],
            &unsqueeze183_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape87_out1 = pad14_out1.reshape(concat104_out1);
        let slice53_out1 = reshape87_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze184_out1 = [gather91_out1 as i64];
        let unsqueeze185_out1 = [gather92_out1 as i64];
        let unsqueeze186_out1 = [gather93_out1 as i64];
        let unsqueeze187_out1 = [gather94_out1 as i64];
        let concat105_out1: [i64; 4usize] = [
            &unsqueeze184_out1[..],
            &unsqueeze185_out1[..],
            &unsqueeze186_out1[..],
            &unsqueeze187_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape88_out1 = slice53_out1.reshape(concat105_out1);
        let transpose72_out1 = reshape82_out1.permute([0, 2, 3, 1]);
        let matmul69_out1 = transpose68_out1.matmul(transpose72_out1);
        let shape107_out1: [i64; 4] = {
            let axes = &matmul69_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice54_out1: [i64; 1] = shape107_out1[3..4].try_into().unwrap();
        let squeeze6_out1 = slice54_out1[0] as i64;
        let unsqueeze188_out1 = [squeeze6_out1 as i64];
        let slice55_out1 = reshape88_out1.slice(s![.., .., .., 0..unsqueeze188_out1[0]]);
        let add52_out1 = matmul69_out1.add(slice55_out1);
        let constant1278_out1 = self.constant1278.val();
        let div10_out1 = add52_out1
            .div((constant1278_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape108_out1: [i64; 4] = {
            let axes = &transpose67_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather95_out1 = shape108_out1[0] as i64;
        let constant1280_out1 = -10000f32;
        let where34_out1 = div10_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1280_out1);
        let softmax6_out1 = burn::tensor::activation::softmax(where34_out1, 3);
        let constant1281_out1 = 0f32;
        let where35_out1 = softmax6_out1.mask_fill(unsqueeze117_out1, constant1281_out1);
        let matmul70_out1 = where35_out1.matmul(transpose67_out1);
        let transpose73_out1 = matmul70_out1.permute([0, 2, 1, 3]);
        let unsqueeze189_out1 = [gather95_out1 as i64];
        let constant1284_out1: [i64; 1] = [512i64];
        let constant1283_out1: [i64; 1] = [-1i64];
        let concat106_out1: [i64; 3usize] = [
            &unsqueeze189_out1[..],
            &constant1283_out1[..],
            &constant1284_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape89_out1 = transpose73_out1.reshape(concat106_out1);
        let linear53_out1 = self.linear53.forward(reshape89_out1);
        let add53_out1 = add49_out1.add(linear53_out1);
        (add53_out1, gather88_out1, concat99_out1, slice49_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule11 {
    layernormalization33: LayerNorm,
    conv1d16: Conv1d,
    conv1d17: Conv1d,
    layernormalization34: LayerNorm,
    conv1d18: Conv1d,
    layernormalization35: LayerNorm,
    linear54: Linear,
    linear55: Linear,
    constant1298: burn::module::Param<Tensor<1>>,
    layernormalization36: LayerNorm,
    layernormalization37: LayerNorm,
    linear56: Linear,
    linear57: Linear,
    constant1299: burn::module::Param<Tensor<1>>,
    layernormalization38: LayerNorm,
    linear58: Linear,
    linear59: Linear,
    linear60: Linear,
    linear61: Linear,
    constant125: burn::module::Param<Tensor<2>>,
    constant126: burn::module::Param<Tensor<2>>,
    constant1354: burn::module::Param<Tensor<1>>,
    linear62: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule11 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization33 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d16 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d17 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization34 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d18 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization35 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear54 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear55 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1298: 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 layernormalization36 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization37 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear56 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear57 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1299: 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 layernormalization38 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear58 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear59 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear60 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear61 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant125: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant126: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1354: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear62 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization33,
            conv1d16,
            conv1d17,
            layernormalization34,
            conv1d18,
            layernormalization35,
            linear54,
            linear55,
            constant1298,
            layernormalization36,
            layernormalization37,
            linear56,
            linear57,
            constant1299,
            layernormalization38,
            linear58,
            linear59,
            linear60,
            linear61,
            constant125,
            constant126,
            constant1354,
            linear62,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add53_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather88_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization33_out1 = {
            let dtype = add53_out1.clone().dtype();
            self.layernormalization33
                .forward(add53_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose74_out1 = layernormalization33_out1.permute([0, 2, 1]);
        let conv1d16_out1 = self.conv1d16.forward(transpose74_out1);
        let split_tensors = conv1d16_out1.split_with_sizes([512, 512].into(), 1);
        let [split6_out1, split6_out2] = split_tensors.try_into().unwrap();
        let sigmoid22_out1 = burn::tensor::activation::sigmoid(split6_out2);
        let mul78_out1 = split6_out1.mul(sigmoid22_out1);
        let constant1285_out1 = 0f32;
        let where36_out1 = mul78_out1.mask_fill(unsqueeze119_out1, constant1285_out1);
        let concat108_out1 = burn::tensor::Tensor::cat(
            [gather88_out1, where36_out1].into(),
            2,
        );
        let slice57_out1 = concat108_out1.clone().slice(s![.., .., - 8..]);
        let conv1d17_out1 = self.conv1d17.forward(concat108_out1);
        let transpose76_out1 = conv1d17_out1.permute([0, 2, 1]);
        let layernormalization34_out1 = {
            let dtype = transpose76_out1.dtype();
            self.layernormalization34
                .forward(transpose76_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose77_out1 = layernormalization34_out1.permute([0, 2, 1]);
        let sigmoid23_out1 = burn::tensor::activation::sigmoid(transpose77_out1.clone());
        let mul79_out1 = transpose77_out1.mul(sigmoid23_out1);
        let conv1d18_out1 = self.conv1d18.forward(mul79_out1);
        let transpose78_out1 = conv1d18_out1.permute([0, 2, 1]);
        let add54_out1 = add53_out1.add(transpose78_out1);
        let layernormalization35_out1 = {
            let dtype = add54_out1.clone().dtype();
            self.layernormalization35
                .forward(add54_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear54_out1 = self.linear54.forward(layernormalization35_out1);
        let sigmoid24_out1 = burn::tensor::activation::sigmoid(linear54_out1.clone());
        let mul80_out1 = linear54_out1.mul(sigmoid24_out1);
        let linear55_out1 = self.linear55.forward(mul80_out1);
        let constant1298_out1 = self.constant1298.val();
        let mul81_out1 = linear55_out1
            .mul((constant1298_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add55_out1 = add54_out1.add(mul81_out1);
        let layernormalization36_out1 = {
            let dtype = add55_out1.dtype();
            self.layernormalization36
                .forward(add55_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather96_out1 = {
            let sliced = cache_last_channel.slice(s![6, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather97_out1 = {
            let sliced = cache_last_time.slice(s![6, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization37_out1 = {
            let dtype = layernormalization36_out1.clone().dtype();
            self.layernormalization37
                .forward(
                    layernormalization36_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear56_out1 = self.linear56.forward(layernormalization37_out1);
        let sigmoid25_out1 = burn::tensor::activation::sigmoid(linear56_out1.clone());
        let mul82_out1 = linear56_out1.mul(sigmoid25_out1);
        let linear57_out1 = self.linear57.forward(mul82_out1);
        let constant1299_out1 = self.constant1299.val();
        let mul83_out1 = linear57_out1
            .mul((constant1299_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add56_out1 = layernormalization36_out1.add(mul83_out1);
        let layernormalization38_out1 = {
            let dtype = add56_out1.clone().dtype();
            self.layernormalization38
                .forward(add56_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat109_out1 = burn::tensor::Tensor::cat(
            [gather96_out1.clone(), layernormalization38_out1.clone()].into(),
            1,
        );
        let shape109_out1: [i64; 3] = {
            let axes = &layernormalization38_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather98_out1 = shape109_out1[1] as i64;
        let unsqueeze190_out1 = [gather98_out1 as i64];
        let slice58_out1 = gather96_out1
            .slice(s![.., unsqueeze190_out1[0]..9223372036854775807, ..]);
        let unsqueeze191_out1 = [gather98_out1 as i64];
        let slice59_out1 = layernormalization38_out1
            .clone()
            .slice(s![.., 0..unsqueeze191_out1[0], ..]);
        let concat110_out1 = burn::tensor::Tensor::cat(
            [slice58_out1, slice59_out1].into(),
            1,
        );
        let gather99_out1 = shape109_out1[0] as i64;
        let linear58_out1 = self.linear58.forward(layernormalization38_out1);
        let unsqueeze192_out1 = [gather99_out1 as i64];
        let constant1313_out1: [i64; 1] = [64i64];
        let constant1311_out1: [i64; 1] = [-1i64];
        let constant1312_out1: [i64; 1] = [8i64];
        let concat111_out1: [i64; 4usize] = [
            &unsqueeze192_out1[..],
            &constant1311_out1[..],
            &constant1312_out1[..],
            &constant1313_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze193_out1 = [gather99_out1 as i64];
        let constant1317_out1: [i64; 1] = [64i64];
        let constant1315_out1: [i64; 1] = [-1i64];
        let constant1316_out1: [i64; 1] = [8i64];
        let concat112_out1: [i64; 4usize] = [
            &unsqueeze193_out1[..],
            &constant1315_out1[..],
            &constant1316_out1[..],
            &constant1317_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze194_out1 = [gather99_out1 as i64];
        let constant1321_out1: [i64; 1] = [64i64];
        let constant1319_out1: [i64; 1] = [-1i64];
        let constant1320_out1: [i64; 1] = [8i64];
        let concat113_out1: [i64; 4usize] = [
            &unsqueeze194_out1[..],
            &constant1319_out1[..],
            &constant1320_out1[..],
            &constant1321_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape92_out1 = linear58_out1.reshape(concat111_out1);
        let linear59_out1 = self.linear59.forward(concat109_out1.clone());
        let reshape93_out1 = linear59_out1.reshape(concat112_out1);
        let linear60_out1 = self.linear60.forward(concat109_out1);
        let reshape94_out1 = linear60_out1.reshape(concat113_out1);
        let transpose79_out1 = reshape94_out1.permute([0, 2, 1, 3]);
        let linear61_out1 = self.linear61.forward(slice5_out1);
        let reshape95_out1 = linear61_out1.reshape([1, -1, 8, 64]);
        let constant125_out1 = self.constant125.val();
        let add57_out1 = reshape92_out1
            .clone()
            .add((constant125_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose80_out1 = add57_out1.permute([0, 2, 1, 3]);
        let constant126_out1 = self.constant126.val();
        let add58_out1 = reshape92_out1
            .add((constant126_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose81_out1 = add58_out1.permute([0, 2, 1, 3]);
        let transpose82_out1 = reshape95_out1.permute([0, 2, 3, 1]);
        let matmul80_out1 = transpose81_out1.matmul(transpose82_out1);
        let shape111_out1: [i64; 4] = {
            let axes = &matmul80_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather100_out1 = shape111_out1[0] as i64;
        let gather101_out1 = shape111_out1[1] as i64;
        let gather102_out1 = shape111_out1[2] as i64;
        let gather103_out1 = shape111_out1[3] as i64;
        let pad16_out1 = matmul80_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze195_out1 = [gather100_out1 as i64];
        let unsqueeze196_out1 = [gather101_out1 as i64];
        let unsqueeze197_out1 = [gather102_out1 as i64];
        let constant1336_out1: [i64; 1] = [-1i64];
        let concat115_out1: [i64; 4usize] = [
            &unsqueeze195_out1[..],
            &unsqueeze196_out1[..],
            &constant1336_out1[..],
            &unsqueeze197_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape98_out1 = pad16_out1.reshape(concat115_out1);
        let slice61_out1 = reshape98_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze198_out1 = [gather100_out1 as i64];
        let unsqueeze199_out1 = [gather101_out1 as i64];
        let unsqueeze200_out1 = [gather102_out1 as i64];
        let unsqueeze201_out1 = [gather103_out1 as i64];
        let concat116_out1: [i64; 4usize] = [
            &unsqueeze198_out1[..],
            &unsqueeze199_out1[..],
            &unsqueeze200_out1[..],
            &unsqueeze201_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape99_out1 = slice61_out1.reshape(concat116_out1);
        let transpose84_out1 = reshape93_out1.permute([0, 2, 3, 1]);
        let matmul81_out1 = transpose80_out1.matmul(transpose84_out1);
        let shape115_out1: [i64; 4] = {
            let axes = &matmul81_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice62_out1: [i64; 1] = shape115_out1[3..4].try_into().unwrap();
        let squeeze7_out1 = slice62_out1[0] as i64;
        let unsqueeze202_out1 = [squeeze7_out1 as i64];
        let slice63_out1 = reshape99_out1.slice(s![.., .., .., 0..unsqueeze202_out1[0]]);
        let add59_out1 = matmul81_out1.add(slice63_out1);
        let constant1354_out1 = self.constant1354.val();
        let div11_out1 = add59_out1
            .div((constant1354_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape116_out1: [i64; 4] = {
            let axes = &transpose79_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather104_out1 = shape116_out1[0] as i64;
        let constant1356_out1 = -10000f32;
        let where37_out1 = div11_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1356_out1);
        let softmax7_out1 = burn::tensor::activation::softmax(where37_out1, 3);
        let constant1357_out1 = 0f32;
        let where38_out1 = softmax7_out1.mask_fill(unsqueeze117_out1, constant1357_out1);
        let matmul82_out1 = where38_out1.matmul(transpose79_out1);
        let transpose85_out1 = matmul82_out1.permute([0, 2, 1, 3]);
        let unsqueeze203_out1 = [gather104_out1 as i64];
        let constant1360_out1: [i64; 1] = [512i64];
        let constant1359_out1: [i64; 1] = [-1i64];
        let concat117_out1: [i64; 3usize] = [
            &unsqueeze203_out1[..],
            &constant1359_out1[..],
            &constant1360_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape100_out1 = transpose85_out1.reshape(concat117_out1);
        let linear62_out1 = self.linear62.forward(reshape100_out1);
        let add60_out1 = add56_out1.add(linear62_out1);
        (add60_out1, gather97_out1, concat110_out1, slice57_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule12 {
    layernormalization39: LayerNorm,
    conv1d19: Conv1d,
    conv1d20: Conv1d,
    layernormalization40: LayerNorm,
    conv1d21: Conv1d,
    layernormalization41: LayerNorm,
    linear63: Linear,
    linear64: Linear,
    constant1374: burn::module::Param<Tensor<1>>,
    layernormalization42: LayerNorm,
    layernormalization43: LayerNorm,
    linear65: Linear,
    linear66: Linear,
    constant1376: burn::module::Param<Tensor<1>>,
    layernormalization44: LayerNorm,
    linear67: Linear,
    linear68: Linear,
    linear69: Linear,
    linear70: Linear,
    constant142: burn::module::Param<Tensor<2>>,
    constant143: burn::module::Param<Tensor<2>>,
    constant1431: burn::module::Param<Tensor<1>>,
    linear71: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule12 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization39 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d19 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d20 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization40 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d21 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization41 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear63 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear64 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1374: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization43 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear65 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear66 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1376: 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 layernormalization44 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear67 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear68 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear69 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear70 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant142: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant143: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1431: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear71 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization39,
            conv1d19,
            conv1d20,
            layernormalization40,
            conv1d21,
            layernormalization41,
            linear63,
            linear64,
            constant1374,
            layernormalization42,
            layernormalization43,
            linear65,
            linear66,
            constant1376,
            layernormalization44,
            linear67,
            linear68,
            linear69,
            linear70,
            constant142,
            constant143,
            constant1431,
            linear71,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add60_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather97_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization39_out1 = {
            let dtype = add60_out1.clone().dtype();
            self.layernormalization39
                .forward(add60_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose86_out1 = layernormalization39_out1.permute([0, 2, 1]);
        let conv1d19_out1 = self.conv1d19.forward(transpose86_out1);
        let split_tensors = conv1d19_out1.split_with_sizes([512, 512].into(), 1);
        let [split7_out1, split7_out2] = split_tensors.try_into().unwrap();
        let sigmoid26_out1 = burn::tensor::activation::sigmoid(split7_out2);
        let mul84_out1 = split7_out1.mul(sigmoid26_out1);
        let constant1361_out1 = 0f32;
        let where39_out1 = mul84_out1.mask_fill(unsqueeze119_out1, constant1361_out1);
        let concat119_out1 = burn::tensor::Tensor::cat(
            [gather97_out1, where39_out1].into(),
            2,
        );
        let slice65_out1 = concat119_out1.clone().slice(s![.., .., - 8..]);
        let conv1d20_out1 = self.conv1d20.forward(concat119_out1);
        let transpose88_out1 = conv1d20_out1.permute([0, 2, 1]);
        let layernormalization40_out1 = {
            let dtype = transpose88_out1.dtype();
            self.layernormalization40
                .forward(transpose88_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose89_out1 = layernormalization40_out1.permute([0, 2, 1]);
        let sigmoid27_out1 = burn::tensor::activation::sigmoid(transpose89_out1.clone());
        let mul85_out1 = transpose89_out1.mul(sigmoid27_out1);
        let conv1d21_out1 = self.conv1d21.forward(mul85_out1);
        let transpose90_out1 = conv1d21_out1.permute([0, 2, 1]);
        let add61_out1 = add60_out1.add(transpose90_out1);
        let layernormalization41_out1 = {
            let dtype = add61_out1.clone().dtype();
            self.layernormalization41
                .forward(add61_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear63_out1 = self.linear63.forward(layernormalization41_out1);
        let sigmoid28_out1 = burn::tensor::activation::sigmoid(linear63_out1.clone());
        let mul86_out1 = linear63_out1.mul(sigmoid28_out1);
        let linear64_out1 = self.linear64.forward(mul86_out1);
        let constant1374_out1 = self.constant1374.val();
        let mul87_out1 = linear64_out1
            .mul((constant1374_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add62_out1 = add61_out1.add(mul87_out1);
        let layernormalization42_out1 = {
            let dtype = add62_out1.dtype();
            self.layernormalization42
                .forward(add62_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather105_out1 = {
            let sliced = cache_last_channel.slice(s![7, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather106_out1 = {
            let sliced = cache_last_time.slice(s![7, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization43_out1 = {
            let dtype = layernormalization42_out1.clone().dtype();
            self.layernormalization43
                .forward(
                    layernormalization42_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear65_out1 = self.linear65.forward(layernormalization43_out1);
        let sigmoid29_out1 = burn::tensor::activation::sigmoid(linear65_out1.clone());
        let mul88_out1 = linear65_out1.mul(sigmoid29_out1);
        let linear66_out1 = self.linear66.forward(mul88_out1);
        let constant1376_out1 = self.constant1376.val();
        let mul89_out1 = linear66_out1
            .mul((constant1376_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add63_out1 = layernormalization42_out1.add(mul89_out1);
        let layernormalization44_out1 = {
            let dtype = add63_out1.clone().dtype();
            self.layernormalization44
                .forward(add63_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat120_out1 = burn::tensor::Tensor::cat(
            [gather105_out1.clone(), layernormalization44_out1.clone()].into(),
            1,
        );
        let shape117_out1: [i64; 3] = {
            let axes = &layernormalization44_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather107_out1 = shape117_out1[1] as i64;
        let unsqueeze204_out1 = [gather107_out1 as i64];
        let slice66_out1 = gather105_out1
            .slice(s![.., unsqueeze204_out1[0]..9223372036854775807, ..]);
        let unsqueeze205_out1 = [gather107_out1 as i64];
        let slice67_out1 = layernormalization44_out1
            .clone()
            .slice(s![.., 0..unsqueeze205_out1[0], ..]);
        let concat121_out1 = burn::tensor::Tensor::cat(
            [slice66_out1, slice67_out1].into(),
            1,
        );
        let gather108_out1 = shape117_out1[0] as i64;
        let linear67_out1 = self.linear67.forward(layernormalization44_out1);
        let unsqueeze206_out1 = [gather108_out1 as i64];
        let constant1390_out1: [i64; 1] = [64i64];
        let constant1388_out1: [i64; 1] = [-1i64];
        let constant1389_out1: [i64; 1] = [8i64];
        let concat122_out1: [i64; 4usize] = [
            &unsqueeze206_out1[..],
            &constant1388_out1[..],
            &constant1389_out1[..],
            &constant1390_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze207_out1 = [gather108_out1 as i64];
        let constant1394_out1: [i64; 1] = [64i64];
        let constant1392_out1: [i64; 1] = [-1i64];
        let constant1393_out1: [i64; 1] = [8i64];
        let concat123_out1: [i64; 4usize] = [
            &unsqueeze207_out1[..],
            &constant1392_out1[..],
            &constant1393_out1[..],
            &constant1394_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze208_out1 = [gather108_out1 as i64];
        let constant1398_out1: [i64; 1] = [64i64];
        let constant1396_out1: [i64; 1] = [-1i64];
        let constant1397_out1: [i64; 1] = [8i64];
        let concat124_out1: [i64; 4usize] = [
            &unsqueeze208_out1[..],
            &constant1396_out1[..],
            &constant1397_out1[..],
            &constant1398_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape103_out1 = linear67_out1.reshape(concat122_out1);
        let linear68_out1 = self.linear68.forward(concat120_out1.clone());
        let reshape104_out1 = linear68_out1.reshape(concat123_out1);
        let linear69_out1 = self.linear69.forward(concat120_out1);
        let reshape105_out1 = linear69_out1.reshape(concat124_out1);
        let transpose91_out1 = reshape105_out1.permute([0, 2, 1, 3]);
        let linear70_out1 = self.linear70.forward(slice5_out1);
        let reshape106_out1 = linear70_out1.reshape([1, -1, 8, 64]);
        let constant142_out1 = self.constant142.val();
        let add64_out1 = reshape103_out1
            .clone()
            .add((constant142_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose92_out1 = add64_out1.permute([0, 2, 1, 3]);
        let constant143_out1 = self.constant143.val();
        let add65_out1 = reshape103_out1
            .add((constant143_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose93_out1 = add65_out1.permute([0, 2, 1, 3]);
        let transpose94_out1 = reshape106_out1.permute([0, 2, 3, 1]);
        let matmul92_out1 = transpose93_out1.matmul(transpose94_out1);
        let shape119_out1: [i64; 4] = {
            let axes = &matmul92_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather109_out1 = shape119_out1[0] as i64;
        let gather110_out1 = shape119_out1[1] as i64;
        let gather111_out1 = shape119_out1[2] as i64;
        let gather112_out1 = shape119_out1[3] as i64;
        let pad18_out1 = matmul92_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze209_out1 = [gather109_out1 as i64];
        let unsqueeze210_out1 = [gather110_out1 as i64];
        let unsqueeze211_out1 = [gather111_out1 as i64];
        let constant1413_out1: [i64; 1] = [-1i64];
        let concat126_out1: [i64; 4usize] = [
            &unsqueeze209_out1[..],
            &unsqueeze210_out1[..],
            &constant1413_out1[..],
            &unsqueeze211_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape109_out1 = pad18_out1.reshape(concat126_out1);
        let slice69_out1 = reshape109_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze212_out1 = [gather109_out1 as i64];
        let unsqueeze213_out1 = [gather110_out1 as i64];
        let unsqueeze214_out1 = [gather111_out1 as i64];
        let unsqueeze215_out1 = [gather112_out1 as i64];
        let concat127_out1: [i64; 4usize] = [
            &unsqueeze212_out1[..],
            &unsqueeze213_out1[..],
            &unsqueeze214_out1[..],
            &unsqueeze215_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape110_out1 = slice69_out1.reshape(concat127_out1);
        let transpose96_out1 = reshape104_out1.permute([0, 2, 3, 1]);
        let matmul93_out1 = transpose92_out1.matmul(transpose96_out1);
        let shape123_out1: [i64; 4] = {
            let axes = &matmul93_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice70_out1: [i64; 1] = shape123_out1[3..4].try_into().unwrap();
        let squeeze8_out1 = slice70_out1[0] as i64;
        let unsqueeze216_out1 = [squeeze8_out1 as i64];
        let slice71_out1 = reshape110_out1
            .slice(s![.., .., .., 0..unsqueeze216_out1[0]]);
        let add66_out1 = matmul93_out1.add(slice71_out1);
        let constant1431_out1 = self.constant1431.val();
        let div12_out1 = add66_out1
            .div((constant1431_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape124_out1: [i64; 4] = {
            let axes = &transpose91_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather113_out1 = shape124_out1[0] as i64;
        let constant1433_out1 = -10000f32;
        let where40_out1 = div12_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1433_out1);
        let softmax8_out1 = burn::tensor::activation::softmax(where40_out1, 3);
        let constant1434_out1 = 0f32;
        let where41_out1 = softmax8_out1.mask_fill(unsqueeze117_out1, constant1434_out1);
        let matmul94_out1 = where41_out1.matmul(transpose91_out1);
        let transpose97_out1 = matmul94_out1.permute([0, 2, 1, 3]);
        let unsqueeze217_out1 = [gather113_out1 as i64];
        let constant1437_out1: [i64; 1] = [512i64];
        let constant1436_out1: [i64; 1] = [-1i64];
        let concat128_out1: [i64; 3usize] = [
            &unsqueeze217_out1[..],
            &constant1436_out1[..],
            &constant1437_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape111_out1 = transpose97_out1.reshape(concat128_out1);
        let linear71_out1 = self.linear71.forward(reshape111_out1);
        let add67_out1 = add63_out1.add(linear71_out1);
        (add67_out1, gather106_out1, concat121_out1, slice65_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule13 {
    layernormalization45: LayerNorm,
    conv1d22: Conv1d,
    conv1d23: Conv1d,
    layernormalization46: LayerNorm,
    conv1d24: Conv1d,
    layernormalization47: LayerNorm,
    linear72: Linear,
    linear73: Linear,
    constant1451: burn::module::Param<Tensor<1>>,
    layernormalization48: LayerNorm,
    layernormalization49: LayerNorm,
    linear74: Linear,
    linear75: Linear,
    constant1452: burn::module::Param<Tensor<1>>,
    layernormalization50: LayerNorm,
    linear76: Linear,
    linear77: Linear,
    linear78: Linear,
    linear79: Linear,
    constant159: burn::module::Param<Tensor<2>>,
    constant160: burn::module::Param<Tensor<2>>,
    constant1507: burn::module::Param<Tensor<1>>,
    linear80: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule13 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization45 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d22 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d23 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization46 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d24 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization47 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear72 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear73 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1451: 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 layernormalization48 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization49 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear74 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear75 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1452: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear76 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear77 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear78 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear79 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant159: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant160: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1507: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear80 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization45,
            conv1d22,
            conv1d23,
            layernormalization46,
            conv1d24,
            layernormalization47,
            linear72,
            linear73,
            constant1451,
            layernormalization48,
            layernormalization49,
            linear74,
            linear75,
            constant1452,
            layernormalization50,
            linear76,
            linear77,
            linear78,
            linear79,
            constant159,
            constant160,
            constant1507,
            linear80,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add67_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather106_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization45_out1 = {
            let dtype = add67_out1.clone().dtype();
            self.layernormalization45
                .forward(add67_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose98_out1 = layernormalization45_out1.permute([0, 2, 1]);
        let conv1d22_out1 = self.conv1d22.forward(transpose98_out1);
        let split_tensors = conv1d22_out1.split_with_sizes([512, 512].into(), 1);
        let [split8_out1, split8_out2] = split_tensors.try_into().unwrap();
        let sigmoid30_out1 = burn::tensor::activation::sigmoid(split8_out2);
        let mul90_out1 = split8_out1.mul(sigmoid30_out1);
        let constant1438_out1 = 0f32;
        let where42_out1 = mul90_out1.mask_fill(unsqueeze119_out1, constant1438_out1);
        let concat130_out1 = burn::tensor::Tensor::cat(
            [gather106_out1, where42_out1].into(),
            2,
        );
        let slice73_out1 = concat130_out1.clone().slice(s![.., .., - 8..]);
        let conv1d23_out1 = self.conv1d23.forward(concat130_out1);
        let transpose100_out1 = conv1d23_out1.permute([0, 2, 1]);
        let layernormalization46_out1 = {
            let dtype = transpose100_out1.dtype();
            self.layernormalization46
                .forward(transpose100_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose101_out1 = layernormalization46_out1.permute([0, 2, 1]);
        let sigmoid31_out1 = burn::tensor::activation::sigmoid(
            transpose101_out1.clone(),
        );
        let mul91_out1 = transpose101_out1.mul(sigmoid31_out1);
        let conv1d24_out1 = self.conv1d24.forward(mul91_out1);
        let transpose102_out1 = conv1d24_out1.permute([0, 2, 1]);
        let add68_out1 = add67_out1.add(transpose102_out1);
        let layernormalization47_out1 = {
            let dtype = add68_out1.clone().dtype();
            self.layernormalization47
                .forward(add68_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear72_out1 = self.linear72.forward(layernormalization47_out1);
        let sigmoid32_out1 = burn::tensor::activation::sigmoid(linear72_out1.clone());
        let mul92_out1 = linear72_out1.mul(sigmoid32_out1);
        let linear73_out1 = self.linear73.forward(mul92_out1);
        let constant1451_out1 = self.constant1451.val();
        let mul93_out1 = linear73_out1
            .mul((constant1451_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add69_out1 = add68_out1.add(mul93_out1);
        let layernormalization48_out1 = {
            let dtype = add69_out1.dtype();
            self.layernormalization48
                .forward(add69_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather114_out1 = {
            let sliced = cache_last_channel.slice(s![8, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather115_out1 = {
            let sliced = cache_last_time.slice(s![8, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization49_out1 = {
            let dtype = layernormalization48_out1.clone().dtype();
            self.layernormalization49
                .forward(
                    layernormalization48_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear74_out1 = self.linear74.forward(layernormalization49_out1);
        let sigmoid33_out1 = burn::tensor::activation::sigmoid(linear74_out1.clone());
        let mul94_out1 = linear74_out1.mul(sigmoid33_out1);
        let linear75_out1 = self.linear75.forward(mul94_out1);
        let constant1452_out1 = self.constant1452.val();
        let mul95_out1 = linear75_out1
            .mul((constant1452_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add70_out1 = layernormalization48_out1.add(mul95_out1);
        let layernormalization50_out1 = {
            let dtype = add70_out1.clone().dtype();
            self.layernormalization50
                .forward(add70_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat131_out1 = burn::tensor::Tensor::cat(
            [gather114_out1.clone(), layernormalization50_out1.clone()].into(),
            1,
        );
        let shape125_out1: [i64; 3] = {
            let axes = &layernormalization50_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather116_out1 = shape125_out1[1] as i64;
        let unsqueeze218_out1 = [gather116_out1 as i64];
        let slice74_out1 = gather114_out1
            .slice(s![.., unsqueeze218_out1[0]..9223372036854775807, ..]);
        let unsqueeze219_out1 = [gather116_out1 as i64];
        let slice75_out1 = layernormalization50_out1
            .clone()
            .slice(s![.., 0..unsqueeze219_out1[0], ..]);
        let concat132_out1 = burn::tensor::Tensor::cat(
            [slice74_out1, slice75_out1].into(),
            1,
        );
        let gather117_out1 = shape125_out1[0] as i64;
        let linear76_out1 = self.linear76.forward(layernormalization50_out1);
        let unsqueeze220_out1 = [gather117_out1 as i64];
        let constant1466_out1: [i64; 1] = [64i64];
        let constant1464_out1: [i64; 1] = [-1i64];
        let constant1465_out1: [i64; 1] = [8i64];
        let concat133_out1: [i64; 4usize] = [
            &unsqueeze220_out1[..],
            &constant1464_out1[..],
            &constant1465_out1[..],
            &constant1466_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze221_out1 = [gather117_out1 as i64];
        let constant1470_out1: [i64; 1] = [64i64];
        let constant1468_out1: [i64; 1] = [-1i64];
        let constant1469_out1: [i64; 1] = [8i64];
        let concat134_out1: [i64; 4usize] = [
            &unsqueeze221_out1[..],
            &constant1468_out1[..],
            &constant1469_out1[..],
            &constant1470_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze222_out1 = [gather117_out1 as i64];
        let constant1474_out1: [i64; 1] = [64i64];
        let constant1472_out1: [i64; 1] = [-1i64];
        let constant1473_out1: [i64; 1] = [8i64];
        let concat135_out1: [i64; 4usize] = [
            &unsqueeze222_out1[..],
            &constant1472_out1[..],
            &constant1473_out1[..],
            &constant1474_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape114_out1 = linear76_out1.reshape(concat133_out1);
        let linear77_out1 = self.linear77.forward(concat131_out1.clone());
        let reshape115_out1 = linear77_out1.reshape(concat134_out1);
        let linear78_out1 = self.linear78.forward(concat131_out1);
        let reshape116_out1 = linear78_out1.reshape(concat135_out1);
        let transpose103_out1 = reshape116_out1.permute([0, 2, 1, 3]);
        let linear79_out1 = self.linear79.forward(slice5_out1);
        let reshape117_out1 = linear79_out1.reshape([1, -1, 8, 64]);
        let constant159_out1 = self.constant159.val();
        let add71_out1 = reshape114_out1
            .clone()
            .add((constant159_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose104_out1 = add71_out1.permute([0, 2, 1, 3]);
        let constant160_out1 = self.constant160.val();
        let add72_out1 = reshape114_out1
            .add((constant160_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose105_out1 = add72_out1.permute([0, 2, 1, 3]);
        let transpose106_out1 = reshape117_out1.permute([0, 2, 3, 1]);
        let matmul104_out1 = transpose105_out1.matmul(transpose106_out1);
        let shape127_out1: [i64; 4] = {
            let axes = &matmul104_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather118_out1 = shape127_out1[0] as i64;
        let gather119_out1 = shape127_out1[1] as i64;
        let gather120_out1 = shape127_out1[2] as i64;
        let gather121_out1 = shape127_out1[3] as i64;
        let pad20_out1 = matmul104_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze223_out1 = [gather118_out1 as i64];
        let unsqueeze224_out1 = [gather119_out1 as i64];
        let unsqueeze225_out1 = [gather120_out1 as i64];
        let constant1489_out1: [i64; 1] = [-1i64];
        let concat137_out1: [i64; 4usize] = [
            &unsqueeze223_out1[..],
            &unsqueeze224_out1[..],
            &constant1489_out1[..],
            &unsqueeze225_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape120_out1 = pad20_out1.reshape(concat137_out1);
        let slice77_out1 = reshape120_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze226_out1 = [gather118_out1 as i64];
        let unsqueeze227_out1 = [gather119_out1 as i64];
        let unsqueeze228_out1 = [gather120_out1 as i64];
        let unsqueeze229_out1 = [gather121_out1 as i64];
        let concat138_out1: [i64; 4usize] = [
            &unsqueeze226_out1[..],
            &unsqueeze227_out1[..],
            &unsqueeze228_out1[..],
            &unsqueeze229_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape121_out1 = slice77_out1.reshape(concat138_out1);
        let transpose108_out1 = reshape115_out1.permute([0, 2, 3, 1]);
        let matmul105_out1 = transpose104_out1.matmul(transpose108_out1);
        let shape131_out1: [i64; 4] = {
            let axes = &matmul105_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice78_out1: [i64; 1] = shape131_out1[3..4].try_into().unwrap();
        let squeeze9_out1 = slice78_out1[0] as i64;
        let unsqueeze230_out1 = [squeeze9_out1 as i64];
        let slice79_out1 = reshape121_out1
            .slice(s![.., .., .., 0..unsqueeze230_out1[0]]);
        let add73_out1 = matmul105_out1.add(slice79_out1);
        let constant1507_out1 = self.constant1507.val();
        let div13_out1 = add73_out1
            .div((constant1507_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape132_out1: [i64; 4] = {
            let axes = &transpose103_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather122_out1 = shape132_out1[0] as i64;
        let constant1509_out1 = -10000f32;
        let where43_out1 = div13_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1509_out1);
        let softmax9_out1 = burn::tensor::activation::softmax(where43_out1, 3);
        let constant1510_out1 = 0f32;
        let where44_out1 = softmax9_out1.mask_fill(unsqueeze117_out1, constant1510_out1);
        let matmul106_out1 = where44_out1.matmul(transpose103_out1);
        let transpose109_out1 = matmul106_out1.permute([0, 2, 1, 3]);
        let unsqueeze231_out1 = [gather122_out1 as i64];
        let constant1513_out1: [i64; 1] = [512i64];
        let constant1512_out1: [i64; 1] = [-1i64];
        let concat139_out1: [i64; 3usize] = [
            &unsqueeze231_out1[..],
            &constant1512_out1[..],
            &constant1513_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape122_out1 = transpose109_out1.reshape(concat139_out1);
        let linear80_out1 = self.linear80.forward(reshape122_out1);
        let add74_out1 = add70_out1.add(linear80_out1);
        (add74_out1, gather115_out1, concat132_out1, slice73_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule14 {
    layernormalization51: LayerNorm,
    conv1d25: Conv1d,
    conv1d26: Conv1d,
    layernormalization52: LayerNorm,
    conv1d27: Conv1d,
    layernormalization53: LayerNorm,
    linear81: Linear,
    linear82: Linear,
    constant1527: burn::module::Param<Tensor<1>>,
    layernormalization54: LayerNorm,
    layernormalization55: LayerNorm,
    linear83: Linear,
    linear84: Linear,
    constant1529: burn::module::Param<Tensor<1>>,
    layernormalization56: LayerNorm,
    linear85: Linear,
    linear86: Linear,
    linear87: Linear,
    linear88: Linear,
    constant176: burn::module::Param<Tensor<2>>,
    constant177: burn::module::Param<Tensor<2>>,
    constant1584: burn::module::Param<Tensor<1>>,
    linear89: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule14 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization51 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d25 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d26 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization52 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d27 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization53 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear81 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear82 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1527: 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 layernormalization54 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization55 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear83 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear84 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1529: 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 layernormalization56 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear85 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear86 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear87 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear88 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant176: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant177: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1584: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear89 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization51,
            conv1d25,
            conv1d26,
            layernormalization52,
            conv1d27,
            layernormalization53,
            linear81,
            linear82,
            constant1527,
            layernormalization54,
            layernormalization55,
            linear83,
            linear84,
            constant1529,
            layernormalization56,
            linear85,
            linear86,
            linear87,
            linear88,
            constant176,
            constant177,
            constant1584,
            linear89,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add74_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather115_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization51_out1 = {
            let dtype = add74_out1.clone().dtype();
            self.layernormalization51
                .forward(add74_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose110_out1 = layernormalization51_out1.permute([0, 2, 1]);
        let conv1d25_out1 = self.conv1d25.forward(transpose110_out1);
        let split_tensors = conv1d25_out1.split_with_sizes([512, 512].into(), 1);
        let [split9_out1, split9_out2] = split_tensors.try_into().unwrap();
        let sigmoid34_out1 = burn::tensor::activation::sigmoid(split9_out2);
        let mul96_out1 = split9_out1.mul(sigmoid34_out1);
        let constant1514_out1 = 0f32;
        let where45_out1 = mul96_out1.mask_fill(unsqueeze119_out1, constant1514_out1);
        let concat141_out1 = burn::tensor::Tensor::cat(
            [gather115_out1, where45_out1].into(),
            2,
        );
        let slice81_out1 = concat141_out1.clone().slice(s![.., .., - 8..]);
        let conv1d26_out1 = self.conv1d26.forward(concat141_out1);
        let transpose112_out1 = conv1d26_out1.permute([0, 2, 1]);
        let layernormalization52_out1 = {
            let dtype = transpose112_out1.dtype();
            self.layernormalization52
                .forward(transpose112_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose113_out1 = layernormalization52_out1.permute([0, 2, 1]);
        let sigmoid35_out1 = burn::tensor::activation::sigmoid(
            transpose113_out1.clone(),
        );
        let mul97_out1 = transpose113_out1.mul(sigmoid35_out1);
        let conv1d27_out1 = self.conv1d27.forward(mul97_out1);
        let transpose114_out1 = conv1d27_out1.permute([0, 2, 1]);
        let add75_out1 = add74_out1.add(transpose114_out1);
        let layernormalization53_out1 = {
            let dtype = add75_out1.clone().dtype();
            self.layernormalization53
                .forward(add75_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear81_out1 = self.linear81.forward(layernormalization53_out1);
        let sigmoid36_out1 = burn::tensor::activation::sigmoid(linear81_out1.clone());
        let mul98_out1 = linear81_out1.mul(sigmoid36_out1);
        let linear82_out1 = self.linear82.forward(mul98_out1);
        let constant1527_out1 = self.constant1527.val();
        let mul99_out1 = linear82_out1
            .mul((constant1527_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add76_out1 = add75_out1.add(mul99_out1);
        let layernormalization54_out1 = {
            let dtype = add76_out1.dtype();
            self.layernormalization54
                .forward(add76_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather123_out1 = {
            let sliced = cache_last_channel.slice(s![9, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather124_out1 = {
            let sliced = cache_last_time.slice(s![9, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization55_out1 = {
            let dtype = layernormalization54_out1.clone().dtype();
            self.layernormalization55
                .forward(
                    layernormalization54_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear83_out1 = self.linear83.forward(layernormalization55_out1);
        let sigmoid37_out1 = burn::tensor::activation::sigmoid(linear83_out1.clone());
        let mul100_out1 = linear83_out1.mul(sigmoid37_out1);
        let linear84_out1 = self.linear84.forward(mul100_out1);
        let constant1529_out1 = self.constant1529.val();
        let mul101_out1 = linear84_out1
            .mul((constant1529_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add77_out1 = layernormalization54_out1.add(mul101_out1);
        let layernormalization56_out1 = {
            let dtype = add77_out1.clone().dtype();
            self.layernormalization56
                .forward(add77_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat142_out1 = burn::tensor::Tensor::cat(
            [gather123_out1.clone(), layernormalization56_out1.clone()].into(),
            1,
        );
        let shape133_out1: [i64; 3] = {
            let axes = &layernormalization56_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather125_out1 = shape133_out1[1] as i64;
        let unsqueeze232_out1 = [gather125_out1 as i64];
        let slice82_out1 = gather123_out1
            .slice(s![.., unsqueeze232_out1[0]..9223372036854775807, ..]);
        let unsqueeze233_out1 = [gather125_out1 as i64];
        let slice83_out1 = layernormalization56_out1
            .clone()
            .slice(s![.., 0..unsqueeze233_out1[0], ..]);
        let concat143_out1 = burn::tensor::Tensor::cat(
            [slice82_out1, slice83_out1].into(),
            1,
        );
        let gather126_out1 = shape133_out1[0] as i64;
        let linear85_out1 = self.linear85.forward(layernormalization56_out1);
        let unsqueeze234_out1 = [gather126_out1 as i64];
        let constant1543_out1: [i64; 1] = [64i64];
        let constant1541_out1: [i64; 1] = [-1i64];
        let constant1542_out1: [i64; 1] = [8i64];
        let concat144_out1: [i64; 4usize] = [
            &unsqueeze234_out1[..],
            &constant1541_out1[..],
            &constant1542_out1[..],
            &constant1543_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze235_out1 = [gather126_out1 as i64];
        let constant1547_out1: [i64; 1] = [64i64];
        let constant1545_out1: [i64; 1] = [-1i64];
        let constant1546_out1: [i64; 1] = [8i64];
        let concat145_out1: [i64; 4usize] = [
            &unsqueeze235_out1[..],
            &constant1545_out1[..],
            &constant1546_out1[..],
            &constant1547_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze236_out1 = [gather126_out1 as i64];
        let constant1551_out1: [i64; 1] = [64i64];
        let constant1549_out1: [i64; 1] = [-1i64];
        let constant1550_out1: [i64; 1] = [8i64];
        let concat146_out1: [i64; 4usize] = [
            &unsqueeze236_out1[..],
            &constant1549_out1[..],
            &constant1550_out1[..],
            &constant1551_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape125_out1 = linear85_out1.reshape(concat144_out1);
        let linear86_out1 = self.linear86.forward(concat142_out1.clone());
        let reshape126_out1 = linear86_out1.reshape(concat145_out1);
        let linear87_out1 = self.linear87.forward(concat142_out1);
        let reshape127_out1 = linear87_out1.reshape(concat146_out1);
        let transpose115_out1 = reshape127_out1.permute([0, 2, 1, 3]);
        let linear88_out1 = self.linear88.forward(slice5_out1);
        let reshape128_out1 = linear88_out1.reshape([1, -1, 8, 64]);
        let constant176_out1 = self.constant176.val();
        let add78_out1 = reshape125_out1
            .clone()
            .add((constant176_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose116_out1 = add78_out1.permute([0, 2, 1, 3]);
        let constant177_out1 = self.constant177.val();
        let add79_out1 = reshape125_out1
            .add((constant177_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose117_out1 = add79_out1.permute([0, 2, 1, 3]);
        let transpose118_out1 = reshape128_out1.permute([0, 2, 3, 1]);
        let matmul116_out1 = transpose117_out1.matmul(transpose118_out1);
        let shape135_out1: [i64; 4] = {
            let axes = &matmul116_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather127_out1 = shape135_out1[0] as i64;
        let gather128_out1 = shape135_out1[1] as i64;
        let gather129_out1 = shape135_out1[2] as i64;
        let gather130_out1 = shape135_out1[3] as i64;
        let pad22_out1 = matmul116_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze237_out1 = [gather127_out1 as i64];
        let unsqueeze238_out1 = [gather128_out1 as i64];
        let unsqueeze239_out1 = [gather129_out1 as i64];
        let constant1566_out1: [i64; 1] = [-1i64];
        let concat148_out1: [i64; 4usize] = [
            &unsqueeze237_out1[..],
            &unsqueeze238_out1[..],
            &constant1566_out1[..],
            &unsqueeze239_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape131_out1 = pad22_out1.reshape(concat148_out1);
        let slice85_out1 = reshape131_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze240_out1 = [gather127_out1 as i64];
        let unsqueeze241_out1 = [gather128_out1 as i64];
        let unsqueeze242_out1 = [gather129_out1 as i64];
        let unsqueeze243_out1 = [gather130_out1 as i64];
        let concat149_out1: [i64; 4usize] = [
            &unsqueeze240_out1[..],
            &unsqueeze241_out1[..],
            &unsqueeze242_out1[..],
            &unsqueeze243_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape132_out1 = slice85_out1.reshape(concat149_out1);
        let transpose120_out1 = reshape126_out1.permute([0, 2, 3, 1]);
        let matmul117_out1 = transpose116_out1.matmul(transpose120_out1);
        let shape139_out1: [i64; 4] = {
            let axes = &matmul117_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice86_out1: [i64; 1] = shape139_out1[3..4].try_into().unwrap();
        let squeeze10_out1 = slice86_out1[0] as i64;
        let unsqueeze244_out1 = [squeeze10_out1 as i64];
        let slice87_out1 = reshape132_out1
            .slice(s![.., .., .., 0..unsqueeze244_out1[0]]);
        let add80_out1 = matmul117_out1.add(slice87_out1);
        let constant1584_out1 = self.constant1584.val();
        let div14_out1 = add80_out1
            .div((constant1584_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape140_out1: [i64; 4] = {
            let axes = &transpose115_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather131_out1 = shape140_out1[0] as i64;
        let constant1586_out1 = -10000f32;
        let where46_out1 = div14_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1586_out1);
        let softmax10_out1 = burn::tensor::activation::softmax(where46_out1, 3);
        let constant1587_out1 = 0f32;
        let where47_out1 = softmax10_out1
            .mask_fill(unsqueeze117_out1, constant1587_out1);
        let matmul118_out1 = where47_out1.matmul(transpose115_out1);
        let transpose121_out1 = matmul118_out1.permute([0, 2, 1, 3]);
        let unsqueeze245_out1 = [gather131_out1 as i64];
        let constant1590_out1: [i64; 1] = [512i64];
        let constant1589_out1: [i64; 1] = [-1i64];
        let concat150_out1: [i64; 3usize] = [
            &unsqueeze245_out1[..],
            &constant1589_out1[..],
            &constant1590_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape133_out1 = transpose121_out1.reshape(concat150_out1);
        let linear89_out1 = self.linear89.forward(reshape133_out1);
        let add81_out1 = add77_out1.add(linear89_out1);
        (add81_out1, gather124_out1, concat143_out1, slice81_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule15 {
    layernormalization57: LayerNorm,
    conv1d28: Conv1d,
    conv1d29: Conv1d,
    layernormalization58: LayerNorm,
    conv1d30: Conv1d,
    layernormalization59: LayerNorm,
    linear90: Linear,
    linear91: Linear,
    constant1604: burn::module::Param<Tensor<1>>,
    layernormalization60: LayerNorm,
    layernormalization61: LayerNorm,
    linear92: Linear,
    linear93: Linear,
    constant1606: burn::module::Param<Tensor<1>>,
    layernormalization62: LayerNorm,
    linear94: Linear,
    linear95: Linear,
    linear96: Linear,
    linear97: Linear,
    constant193: burn::module::Param<Tensor<2>>,
    constant194: burn::module::Param<Tensor<2>>,
    constant1661: burn::module::Param<Tensor<1>>,
    linear98: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule15 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization57 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d28 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d29 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization58 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d30 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization59 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear90 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear91 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1604: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization61 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear92 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear93 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1606: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear94 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear95 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear96 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear97 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant193: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant194: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1661: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear98 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization57,
            conv1d28,
            conv1d29,
            layernormalization58,
            conv1d30,
            layernormalization59,
            linear90,
            linear91,
            constant1604,
            layernormalization60,
            layernormalization61,
            linear92,
            linear93,
            constant1606,
            layernormalization62,
            linear94,
            linear95,
            linear96,
            linear97,
            constant193,
            constant194,
            constant1661,
            linear98,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add81_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather124_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization57_out1 = {
            let dtype = add81_out1.clone().dtype();
            self.layernormalization57
                .forward(add81_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose122_out1 = layernormalization57_out1.permute([0, 2, 1]);
        let conv1d28_out1 = self.conv1d28.forward(transpose122_out1);
        let split_tensors = conv1d28_out1.split_with_sizes([512, 512].into(), 1);
        let [split10_out1, split10_out2] = split_tensors.try_into().unwrap();
        let sigmoid38_out1 = burn::tensor::activation::sigmoid(split10_out2);
        let mul102_out1 = split10_out1.mul(sigmoid38_out1);
        let constant1591_out1 = 0f32;
        let where48_out1 = mul102_out1.mask_fill(unsqueeze119_out1, constant1591_out1);
        let concat152_out1 = burn::tensor::Tensor::cat(
            [gather124_out1, where48_out1].into(),
            2,
        );
        let slice89_out1 = concat152_out1.clone().slice(s![.., .., - 8..]);
        let conv1d29_out1 = self.conv1d29.forward(concat152_out1);
        let transpose124_out1 = conv1d29_out1.permute([0, 2, 1]);
        let layernormalization58_out1 = {
            let dtype = transpose124_out1.dtype();
            self.layernormalization58
                .forward(transpose124_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose125_out1 = layernormalization58_out1.permute([0, 2, 1]);
        let sigmoid39_out1 = burn::tensor::activation::sigmoid(
            transpose125_out1.clone(),
        );
        let mul103_out1 = transpose125_out1.mul(sigmoid39_out1);
        let conv1d30_out1 = self.conv1d30.forward(mul103_out1);
        let transpose126_out1 = conv1d30_out1.permute([0, 2, 1]);
        let add82_out1 = add81_out1.add(transpose126_out1);
        let layernormalization59_out1 = {
            let dtype = add82_out1.clone().dtype();
            self.layernormalization59
                .forward(add82_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear90_out1 = self.linear90.forward(layernormalization59_out1);
        let sigmoid40_out1 = burn::tensor::activation::sigmoid(linear90_out1.clone());
        let mul104_out1 = linear90_out1.mul(sigmoid40_out1);
        let linear91_out1 = self.linear91.forward(mul104_out1);
        let constant1604_out1 = self.constant1604.val();
        let mul105_out1 = linear91_out1
            .mul((constant1604_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add83_out1 = add82_out1.add(mul105_out1);
        let layernormalization60_out1 = {
            let dtype = add83_out1.dtype();
            self.layernormalization60
                .forward(add83_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather132_out1 = {
            let sliced = cache_last_channel.slice(s![10, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather133_out1 = {
            let sliced = cache_last_time.slice(s![10, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization61_out1 = {
            let dtype = layernormalization60_out1.clone().dtype();
            self.layernormalization61
                .forward(
                    layernormalization60_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear92_out1 = self.linear92.forward(layernormalization61_out1);
        let sigmoid41_out1 = burn::tensor::activation::sigmoid(linear92_out1.clone());
        let mul106_out1 = linear92_out1.mul(sigmoid41_out1);
        let linear93_out1 = self.linear93.forward(mul106_out1);
        let constant1606_out1 = self.constant1606.val();
        let mul107_out1 = linear93_out1
            .mul((constant1606_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add84_out1 = layernormalization60_out1.add(mul107_out1);
        let layernormalization62_out1 = {
            let dtype = add84_out1.clone().dtype();
            self.layernormalization62
                .forward(add84_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat153_out1 = burn::tensor::Tensor::cat(
            [gather132_out1.clone(), layernormalization62_out1.clone()].into(),
            1,
        );
        let shape141_out1: [i64; 3] = {
            let axes = &layernormalization62_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather134_out1 = shape141_out1[1] as i64;
        let unsqueeze246_out1 = [gather134_out1 as i64];
        let slice90_out1 = gather132_out1
            .slice(s![.., unsqueeze246_out1[0]..9223372036854775807, ..]);
        let unsqueeze247_out1 = [gather134_out1 as i64];
        let slice91_out1 = layernormalization62_out1
            .clone()
            .slice(s![.., 0..unsqueeze247_out1[0], ..]);
        let concat154_out1 = burn::tensor::Tensor::cat(
            [slice90_out1, slice91_out1].into(),
            1,
        );
        let gather135_out1 = shape141_out1[0] as i64;
        let linear94_out1 = self.linear94.forward(layernormalization62_out1);
        let unsqueeze248_out1 = [gather135_out1 as i64];
        let constant1620_out1: [i64; 1] = [64i64];
        let constant1618_out1: [i64; 1] = [-1i64];
        let constant1619_out1: [i64; 1] = [8i64];
        let concat155_out1: [i64; 4usize] = [
            &unsqueeze248_out1[..],
            &constant1618_out1[..],
            &constant1619_out1[..],
            &constant1620_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze249_out1 = [gather135_out1 as i64];
        let constant1624_out1: [i64; 1] = [64i64];
        let constant1622_out1: [i64; 1] = [-1i64];
        let constant1623_out1: [i64; 1] = [8i64];
        let concat156_out1: [i64; 4usize] = [
            &unsqueeze249_out1[..],
            &constant1622_out1[..],
            &constant1623_out1[..],
            &constant1624_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze250_out1 = [gather135_out1 as i64];
        let constant1628_out1: [i64; 1] = [64i64];
        let constant1626_out1: [i64; 1] = [-1i64];
        let constant1627_out1: [i64; 1] = [8i64];
        let concat157_out1: [i64; 4usize] = [
            &unsqueeze250_out1[..],
            &constant1626_out1[..],
            &constant1627_out1[..],
            &constant1628_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape136_out1 = linear94_out1.reshape(concat155_out1);
        let linear95_out1 = self.linear95.forward(concat153_out1.clone());
        let reshape137_out1 = linear95_out1.reshape(concat156_out1);
        let linear96_out1 = self.linear96.forward(concat153_out1);
        let reshape138_out1 = linear96_out1.reshape(concat157_out1);
        let transpose127_out1 = reshape138_out1.permute([0, 2, 1, 3]);
        let linear97_out1 = self.linear97.forward(slice5_out1);
        let reshape139_out1 = linear97_out1.reshape([1, -1, 8, 64]);
        let constant193_out1 = self.constant193.val();
        let add85_out1 = reshape136_out1
            .clone()
            .add((constant193_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose128_out1 = add85_out1.permute([0, 2, 1, 3]);
        let constant194_out1 = self.constant194.val();
        let add86_out1 = reshape136_out1
            .add((constant194_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose129_out1 = add86_out1.permute([0, 2, 1, 3]);
        let transpose130_out1 = reshape139_out1.permute([0, 2, 3, 1]);
        let matmul128_out1 = transpose129_out1.matmul(transpose130_out1);
        let shape143_out1: [i64; 4] = {
            let axes = &matmul128_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather136_out1 = shape143_out1[0] as i64;
        let gather137_out1 = shape143_out1[1] as i64;
        let gather138_out1 = shape143_out1[2] as i64;
        let gather139_out1 = shape143_out1[3] as i64;
        let pad24_out1 = matmul128_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze251_out1 = [gather136_out1 as i64];
        let unsqueeze252_out1 = [gather137_out1 as i64];
        let unsqueeze253_out1 = [gather138_out1 as i64];
        let constant1643_out1: [i64; 1] = [-1i64];
        let concat159_out1: [i64; 4usize] = [
            &unsqueeze251_out1[..],
            &unsqueeze252_out1[..],
            &constant1643_out1[..],
            &unsqueeze253_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape142_out1 = pad24_out1.reshape(concat159_out1);
        let slice93_out1 = reshape142_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze254_out1 = [gather136_out1 as i64];
        let unsqueeze255_out1 = [gather137_out1 as i64];
        let unsqueeze256_out1 = [gather138_out1 as i64];
        let unsqueeze257_out1 = [gather139_out1 as i64];
        let concat160_out1: [i64; 4usize] = [
            &unsqueeze254_out1[..],
            &unsqueeze255_out1[..],
            &unsqueeze256_out1[..],
            &unsqueeze257_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape143_out1 = slice93_out1.reshape(concat160_out1);
        let transpose132_out1 = reshape137_out1.permute([0, 2, 3, 1]);
        let matmul129_out1 = transpose128_out1.matmul(transpose132_out1);
        let shape147_out1: [i64; 4] = {
            let axes = &matmul129_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice94_out1: [i64; 1] = shape147_out1[3..4].try_into().unwrap();
        let squeeze11_out1 = slice94_out1[0] as i64;
        let unsqueeze258_out1 = [squeeze11_out1 as i64];
        let slice95_out1 = reshape143_out1
            .slice(s![.., .., .., 0..unsqueeze258_out1[0]]);
        let add87_out1 = matmul129_out1.add(slice95_out1);
        let constant1661_out1 = self.constant1661.val();
        let div15_out1 = add87_out1
            .div((constant1661_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape148_out1: [i64; 4] = {
            let axes = &transpose127_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather140_out1 = shape148_out1[0] as i64;
        let constant1663_out1 = -10000f32;
        let where49_out1 = div15_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1663_out1);
        let softmax11_out1 = burn::tensor::activation::softmax(where49_out1, 3);
        let constant1664_out1 = 0f32;
        let where50_out1 = softmax11_out1
            .mask_fill(unsqueeze117_out1, constant1664_out1);
        let matmul130_out1 = where50_out1.matmul(transpose127_out1);
        let transpose133_out1 = matmul130_out1.permute([0, 2, 1, 3]);
        let unsqueeze259_out1 = [gather140_out1 as i64];
        let constant1667_out1: [i64; 1] = [512i64];
        let constant1666_out1: [i64; 1] = [-1i64];
        let concat161_out1: [i64; 3usize] = [
            &unsqueeze259_out1[..],
            &constant1666_out1[..],
            &constant1667_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape144_out1 = transpose133_out1.reshape(concat161_out1);
        let linear98_out1 = self.linear98.forward(reshape144_out1);
        let add88_out1 = add84_out1.add(linear98_out1);
        (add88_out1, gather133_out1, concat154_out1, slice89_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule16 {
    layernormalization63: LayerNorm,
    conv1d31: Conv1d,
    conv1d32: Conv1d,
    layernormalization64: LayerNorm,
    conv1d33: Conv1d,
    layernormalization65: LayerNorm,
    linear99: Linear,
    linear100: Linear,
    constant1681: burn::module::Param<Tensor<1>>,
    layernormalization66: LayerNorm,
    layernormalization67: LayerNorm,
    linear101: Linear,
    linear102: Linear,
    constant1682: burn::module::Param<Tensor<1>>,
    layernormalization68: LayerNorm,
    linear103: Linear,
    linear104: Linear,
    linear105: Linear,
    linear106: Linear,
    constant210: burn::module::Param<Tensor<2>>,
    constant211: burn::module::Param<Tensor<2>>,
    constant1737: burn::module::Param<Tensor<1>>,
    linear107: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule16 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization63 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d31 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d32 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization64 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d33 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization65 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear99 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear100 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1681: 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 layernormalization66 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization67 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear101 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear102 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1682: 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 layernormalization68 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear103 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear104 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear105 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear106 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant210: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant211: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1737: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear107 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization63,
            conv1d31,
            conv1d32,
            layernormalization64,
            conv1d33,
            layernormalization65,
            linear99,
            linear100,
            constant1681,
            layernormalization66,
            layernormalization67,
            linear101,
            linear102,
            constant1682,
            layernormalization68,
            linear103,
            linear104,
            linear105,
            linear106,
            constant210,
            constant211,
            constant1737,
            linear107,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add88_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather133_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization63_out1 = {
            let dtype = add88_out1.clone().dtype();
            self.layernormalization63
                .forward(add88_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose134_out1 = layernormalization63_out1.permute([0, 2, 1]);
        let conv1d31_out1 = self.conv1d31.forward(transpose134_out1);
        let split_tensors = conv1d31_out1.split_with_sizes([512, 512].into(), 1);
        let [split11_out1, split11_out2] = split_tensors.try_into().unwrap();
        let sigmoid42_out1 = burn::tensor::activation::sigmoid(split11_out2);
        let mul108_out1 = split11_out1.mul(sigmoid42_out1);
        let constant1668_out1 = 0f32;
        let where51_out1 = mul108_out1.mask_fill(unsqueeze119_out1, constant1668_out1);
        let concat163_out1 = burn::tensor::Tensor::cat(
            [gather133_out1, where51_out1].into(),
            2,
        );
        let slice97_out1 = concat163_out1.clone().slice(s![.., .., - 8..]);
        let conv1d32_out1 = self.conv1d32.forward(concat163_out1);
        let transpose136_out1 = conv1d32_out1.permute([0, 2, 1]);
        let layernormalization64_out1 = {
            let dtype = transpose136_out1.dtype();
            self.layernormalization64
                .forward(transpose136_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose137_out1 = layernormalization64_out1.permute([0, 2, 1]);
        let sigmoid43_out1 = burn::tensor::activation::sigmoid(
            transpose137_out1.clone(),
        );
        let mul109_out1 = transpose137_out1.mul(sigmoid43_out1);
        let conv1d33_out1 = self.conv1d33.forward(mul109_out1);
        let transpose138_out1 = conv1d33_out1.permute([0, 2, 1]);
        let add89_out1 = add88_out1.add(transpose138_out1);
        let layernormalization65_out1 = {
            let dtype = add89_out1.clone().dtype();
            self.layernormalization65
                .forward(add89_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear99_out1 = self.linear99.forward(layernormalization65_out1);
        let sigmoid44_out1 = burn::tensor::activation::sigmoid(linear99_out1.clone());
        let mul110_out1 = linear99_out1.mul(sigmoid44_out1);
        let linear100_out1 = self.linear100.forward(mul110_out1);
        let constant1681_out1 = self.constant1681.val();
        let mul111_out1 = linear100_out1
            .mul((constant1681_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add90_out1 = add89_out1.add(mul111_out1);
        let layernormalization66_out1 = {
            let dtype = add90_out1.dtype();
            self.layernormalization66
                .forward(add90_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather141_out1 = {
            let sliced = cache_last_channel.slice(s![11, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather142_out1 = {
            let sliced = cache_last_time.slice(s![11, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization67_out1 = {
            let dtype = layernormalization66_out1.clone().dtype();
            self.layernormalization67
                .forward(
                    layernormalization66_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear101_out1 = self.linear101.forward(layernormalization67_out1);
        let sigmoid45_out1 = burn::tensor::activation::sigmoid(linear101_out1.clone());
        let mul112_out1 = linear101_out1.mul(sigmoid45_out1);
        let linear102_out1 = self.linear102.forward(mul112_out1);
        let constant1682_out1 = self.constant1682.val();
        let mul113_out1 = linear102_out1
            .mul((constant1682_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add91_out1 = layernormalization66_out1.add(mul113_out1);
        let layernormalization68_out1 = {
            let dtype = add91_out1.clone().dtype();
            self.layernormalization68
                .forward(add91_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat164_out1 = burn::tensor::Tensor::cat(
            [gather141_out1.clone(), layernormalization68_out1.clone()].into(),
            1,
        );
        let shape149_out1: [i64; 3] = {
            let axes = &layernormalization68_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather143_out1 = shape149_out1[1] as i64;
        let unsqueeze260_out1 = [gather143_out1 as i64];
        let slice98_out1 = gather141_out1
            .slice(s![.., unsqueeze260_out1[0]..9223372036854775807, ..]);
        let unsqueeze261_out1 = [gather143_out1 as i64];
        let slice99_out1 = layernormalization68_out1
            .clone()
            .slice(s![.., 0..unsqueeze261_out1[0], ..]);
        let concat165_out1 = burn::tensor::Tensor::cat(
            [slice98_out1, slice99_out1].into(),
            1,
        );
        let gather144_out1 = shape149_out1[0] as i64;
        let linear103_out1 = self.linear103.forward(layernormalization68_out1);
        let unsqueeze262_out1 = [gather144_out1 as i64];
        let constant1696_out1: [i64; 1] = [64i64];
        let constant1694_out1: [i64; 1] = [-1i64];
        let constant1695_out1: [i64; 1] = [8i64];
        let concat166_out1: [i64; 4usize] = [
            &unsqueeze262_out1[..],
            &constant1694_out1[..],
            &constant1695_out1[..],
            &constant1696_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze263_out1 = [gather144_out1 as i64];
        let constant1700_out1: [i64; 1] = [64i64];
        let constant1698_out1: [i64; 1] = [-1i64];
        let constant1699_out1: [i64; 1] = [8i64];
        let concat167_out1: [i64; 4usize] = [
            &unsqueeze263_out1[..],
            &constant1698_out1[..],
            &constant1699_out1[..],
            &constant1700_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze264_out1 = [gather144_out1 as i64];
        let constant1704_out1: [i64; 1] = [64i64];
        let constant1702_out1: [i64; 1] = [-1i64];
        let constant1703_out1: [i64; 1] = [8i64];
        let concat168_out1: [i64; 4usize] = [
            &unsqueeze264_out1[..],
            &constant1702_out1[..],
            &constant1703_out1[..],
            &constant1704_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape147_out1 = linear103_out1.reshape(concat166_out1);
        let linear104_out1 = self.linear104.forward(concat164_out1.clone());
        let reshape148_out1 = linear104_out1.reshape(concat167_out1);
        let linear105_out1 = self.linear105.forward(concat164_out1);
        let reshape149_out1 = linear105_out1.reshape(concat168_out1);
        let transpose139_out1 = reshape149_out1.permute([0, 2, 1, 3]);
        let linear106_out1 = self.linear106.forward(slice5_out1);
        let reshape150_out1 = linear106_out1.reshape([1, -1, 8, 64]);
        let constant210_out1 = self.constant210.val();
        let add92_out1 = reshape147_out1
            .clone()
            .add((constant210_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose140_out1 = add92_out1.permute([0, 2, 1, 3]);
        let constant211_out1 = self.constant211.val();
        let add93_out1 = reshape147_out1
            .add((constant211_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose141_out1 = add93_out1.permute([0, 2, 1, 3]);
        let transpose142_out1 = reshape150_out1.permute([0, 2, 3, 1]);
        let matmul140_out1 = transpose141_out1.matmul(transpose142_out1);
        let shape151_out1: [i64; 4] = {
            let axes = &matmul140_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather145_out1 = shape151_out1[0] as i64;
        let gather146_out1 = shape151_out1[1] as i64;
        let gather147_out1 = shape151_out1[2] as i64;
        let gather148_out1 = shape151_out1[3] as i64;
        let pad26_out1 = matmul140_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze265_out1 = [gather145_out1 as i64];
        let unsqueeze266_out1 = [gather146_out1 as i64];
        let unsqueeze267_out1 = [gather147_out1 as i64];
        let constant1719_out1: [i64; 1] = [-1i64];
        let concat170_out1: [i64; 4usize] = [
            &unsqueeze265_out1[..],
            &unsqueeze266_out1[..],
            &constant1719_out1[..],
            &unsqueeze267_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape153_out1 = pad26_out1.reshape(concat170_out1);
        let slice101_out1 = reshape153_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze268_out1 = [gather145_out1 as i64];
        let unsqueeze269_out1 = [gather146_out1 as i64];
        let unsqueeze270_out1 = [gather147_out1 as i64];
        let unsqueeze271_out1 = [gather148_out1 as i64];
        let concat171_out1: [i64; 4usize] = [
            &unsqueeze268_out1[..],
            &unsqueeze269_out1[..],
            &unsqueeze270_out1[..],
            &unsqueeze271_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape154_out1 = slice101_out1.reshape(concat171_out1);
        let transpose144_out1 = reshape148_out1.permute([0, 2, 3, 1]);
        let matmul141_out1 = transpose140_out1.matmul(transpose144_out1);
        let shape155_out1: [i64; 4] = {
            let axes = &matmul141_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice102_out1: [i64; 1] = shape155_out1[3..4].try_into().unwrap();
        let squeeze12_out1 = slice102_out1[0] as i64;
        let unsqueeze272_out1 = [squeeze12_out1 as i64];
        let slice103_out1 = reshape154_out1
            .slice(s![.., .., .., 0..unsqueeze272_out1[0]]);
        let add94_out1 = matmul141_out1.add(slice103_out1);
        let constant1737_out1 = self.constant1737.val();
        let div16_out1 = add94_out1
            .div((constant1737_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape156_out1: [i64; 4] = {
            let axes = &transpose139_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather149_out1 = shape156_out1[0] as i64;
        let constant1739_out1 = -10000f32;
        let where52_out1 = div16_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1739_out1);
        let softmax12_out1 = burn::tensor::activation::softmax(where52_out1, 3);
        let constant1740_out1 = 0f32;
        let where53_out1 = softmax12_out1
            .mask_fill(unsqueeze117_out1, constant1740_out1);
        let matmul142_out1 = where53_out1.matmul(transpose139_out1);
        let transpose145_out1 = matmul142_out1.permute([0, 2, 1, 3]);
        let unsqueeze273_out1 = [gather149_out1 as i64];
        let constant1743_out1: [i64; 1] = [512i64];
        let constant1742_out1: [i64; 1] = [-1i64];
        let concat172_out1: [i64; 3usize] = [
            &unsqueeze273_out1[..],
            &constant1742_out1[..],
            &constant1743_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape155_out1 = transpose145_out1.reshape(concat172_out1);
        let linear107_out1 = self.linear107.forward(reshape155_out1);
        let add95_out1 = add91_out1.add(linear107_out1);
        (add95_out1, gather142_out1, concat165_out1, slice97_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule17 {
    layernormalization69: LayerNorm,
    conv1d34: Conv1d,
    conv1d35: Conv1d,
    layernormalization70: LayerNorm,
    conv1d36: Conv1d,
    layernormalization71: LayerNorm,
    linear108: Linear,
    linear109: Linear,
    constant1757: burn::module::Param<Tensor<1>>,
    layernormalization72: LayerNorm,
    layernormalization73: LayerNorm,
    linear110: Linear,
    linear111: Linear,
    constant1759: burn::module::Param<Tensor<1>>,
    layernormalization74: LayerNorm,
    linear112: Linear,
    linear113: Linear,
    linear114: Linear,
    linear115: Linear,
    constant227: burn::module::Param<Tensor<2>>,
    constant228: burn::module::Param<Tensor<2>>,
    constant1814: burn::module::Param<Tensor<1>>,
    linear116: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule17 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization69 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d34 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d35 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization70 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d36 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization71 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear108 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear109 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1757: 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 layernormalization72 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization73 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear110 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear111 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1759: 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 layernormalization74 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear112 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear113 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear114 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear115 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant227: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant228: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1814: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear116 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization69,
            conv1d34,
            conv1d35,
            layernormalization70,
            conv1d36,
            layernormalization71,
            linear108,
            linear109,
            constant1757,
            layernormalization72,
            layernormalization73,
            linear110,
            linear111,
            constant1759,
            layernormalization74,
            linear112,
            linear113,
            linear114,
            linear115,
            constant227,
            constant228,
            constant1814,
            linear116,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add95_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather142_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization69_out1 = {
            let dtype = add95_out1.clone().dtype();
            self.layernormalization69
                .forward(add95_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose146_out1 = layernormalization69_out1.permute([0, 2, 1]);
        let conv1d34_out1 = self.conv1d34.forward(transpose146_out1);
        let split_tensors = conv1d34_out1.split_with_sizes([512, 512].into(), 1);
        let [split12_out1, split12_out2] = split_tensors.try_into().unwrap();
        let sigmoid46_out1 = burn::tensor::activation::sigmoid(split12_out2);
        let mul114_out1 = split12_out1.mul(sigmoid46_out1);
        let constant1744_out1 = 0f32;
        let where54_out1 = mul114_out1.mask_fill(unsqueeze119_out1, constant1744_out1);
        let concat174_out1 = burn::tensor::Tensor::cat(
            [gather142_out1, where54_out1].into(),
            2,
        );
        let slice105_out1 = concat174_out1.clone().slice(s![.., .., - 8..]);
        let conv1d35_out1 = self.conv1d35.forward(concat174_out1);
        let transpose148_out1 = conv1d35_out1.permute([0, 2, 1]);
        let layernormalization70_out1 = {
            let dtype = transpose148_out1.dtype();
            self.layernormalization70
                .forward(transpose148_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose149_out1 = layernormalization70_out1.permute([0, 2, 1]);
        let sigmoid47_out1 = burn::tensor::activation::sigmoid(
            transpose149_out1.clone(),
        );
        let mul115_out1 = transpose149_out1.mul(sigmoid47_out1);
        let conv1d36_out1 = self.conv1d36.forward(mul115_out1);
        let transpose150_out1 = conv1d36_out1.permute([0, 2, 1]);
        let add96_out1 = add95_out1.add(transpose150_out1);
        let layernormalization71_out1 = {
            let dtype = add96_out1.clone().dtype();
            self.layernormalization71
                .forward(add96_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear108_out1 = self.linear108.forward(layernormalization71_out1);
        let sigmoid48_out1 = burn::tensor::activation::sigmoid(linear108_out1.clone());
        let mul116_out1 = linear108_out1.mul(sigmoid48_out1);
        let linear109_out1 = self.linear109.forward(mul116_out1);
        let constant1757_out1 = self.constant1757.val();
        let mul117_out1 = linear109_out1
            .mul((constant1757_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add97_out1 = add96_out1.add(mul117_out1);
        let layernormalization72_out1 = {
            let dtype = add97_out1.dtype();
            self.layernormalization72
                .forward(add97_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather150_out1 = {
            let sliced = cache_last_channel.slice(s![12, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather151_out1 = {
            let sliced = cache_last_time.slice(s![12, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization73_out1 = {
            let dtype = layernormalization72_out1.clone().dtype();
            self.layernormalization73
                .forward(
                    layernormalization72_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear110_out1 = self.linear110.forward(layernormalization73_out1);
        let sigmoid49_out1 = burn::tensor::activation::sigmoid(linear110_out1.clone());
        let mul118_out1 = linear110_out1.mul(sigmoid49_out1);
        let linear111_out1 = self.linear111.forward(mul118_out1);
        let constant1759_out1 = self.constant1759.val();
        let mul119_out1 = linear111_out1
            .mul((constant1759_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add98_out1 = layernormalization72_out1.add(mul119_out1);
        let layernormalization74_out1 = {
            let dtype = add98_out1.clone().dtype();
            self.layernormalization74
                .forward(add98_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat175_out1 = burn::tensor::Tensor::cat(
            [gather150_out1.clone(), layernormalization74_out1.clone()].into(),
            1,
        );
        let shape157_out1: [i64; 3] = {
            let axes = &layernormalization74_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather152_out1 = shape157_out1[1] as i64;
        let unsqueeze274_out1 = [gather152_out1 as i64];
        let slice106_out1 = gather150_out1
            .slice(s![.., unsqueeze274_out1[0]..9223372036854775807, ..]);
        let unsqueeze275_out1 = [gather152_out1 as i64];
        let slice107_out1 = layernormalization74_out1
            .clone()
            .slice(s![.., 0..unsqueeze275_out1[0], ..]);
        let concat176_out1 = burn::tensor::Tensor::cat(
            [slice106_out1, slice107_out1].into(),
            1,
        );
        let gather153_out1 = shape157_out1[0] as i64;
        let linear112_out1 = self.linear112.forward(layernormalization74_out1);
        let unsqueeze276_out1 = [gather153_out1 as i64];
        let constant1773_out1: [i64; 1] = [64i64];
        let constant1771_out1: [i64; 1] = [-1i64];
        let constant1772_out1: [i64; 1] = [8i64];
        let concat177_out1: [i64; 4usize] = [
            &unsqueeze276_out1[..],
            &constant1771_out1[..],
            &constant1772_out1[..],
            &constant1773_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze277_out1 = [gather153_out1 as i64];
        let constant1777_out1: [i64; 1] = [64i64];
        let constant1775_out1: [i64; 1] = [-1i64];
        let constant1776_out1: [i64; 1] = [8i64];
        let concat178_out1: [i64; 4usize] = [
            &unsqueeze277_out1[..],
            &constant1775_out1[..],
            &constant1776_out1[..],
            &constant1777_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze278_out1 = [gather153_out1 as i64];
        let constant1781_out1: [i64; 1] = [64i64];
        let constant1779_out1: [i64; 1] = [-1i64];
        let constant1780_out1: [i64; 1] = [8i64];
        let concat179_out1: [i64; 4usize] = [
            &unsqueeze278_out1[..],
            &constant1779_out1[..],
            &constant1780_out1[..],
            &constant1781_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape158_out1 = linear112_out1.reshape(concat177_out1);
        let linear113_out1 = self.linear113.forward(concat175_out1.clone());
        let reshape159_out1 = linear113_out1.reshape(concat178_out1);
        let linear114_out1 = self.linear114.forward(concat175_out1);
        let reshape160_out1 = linear114_out1.reshape(concat179_out1);
        let transpose151_out1 = reshape160_out1.permute([0, 2, 1, 3]);
        let linear115_out1 = self.linear115.forward(slice5_out1);
        let reshape161_out1 = linear115_out1.reshape([1, -1, 8, 64]);
        let constant227_out1 = self.constant227.val();
        let add99_out1 = reshape158_out1
            .clone()
            .add((constant227_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose152_out1 = add99_out1.permute([0, 2, 1, 3]);
        let constant228_out1 = self.constant228.val();
        let add100_out1 = reshape158_out1
            .add((constant228_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose153_out1 = add100_out1.permute([0, 2, 1, 3]);
        let transpose154_out1 = reshape161_out1.permute([0, 2, 3, 1]);
        let matmul152_out1 = transpose153_out1.matmul(transpose154_out1);
        let shape159_out1: [i64; 4] = {
            let axes = &matmul152_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather154_out1 = shape159_out1[0] as i64;
        let gather155_out1 = shape159_out1[1] as i64;
        let gather156_out1 = shape159_out1[2] as i64;
        let gather157_out1 = shape159_out1[3] as i64;
        let pad28_out1 = matmul152_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze279_out1 = [gather154_out1 as i64];
        let unsqueeze280_out1 = [gather155_out1 as i64];
        let unsqueeze281_out1 = [gather156_out1 as i64];
        let constant1796_out1: [i64; 1] = [-1i64];
        let concat181_out1: [i64; 4usize] = [
            &unsqueeze279_out1[..],
            &unsqueeze280_out1[..],
            &constant1796_out1[..],
            &unsqueeze281_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape164_out1 = pad28_out1.reshape(concat181_out1);
        let slice109_out1 = reshape164_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze282_out1 = [gather154_out1 as i64];
        let unsqueeze283_out1 = [gather155_out1 as i64];
        let unsqueeze284_out1 = [gather156_out1 as i64];
        let unsqueeze285_out1 = [gather157_out1 as i64];
        let concat182_out1: [i64; 4usize] = [
            &unsqueeze282_out1[..],
            &unsqueeze283_out1[..],
            &unsqueeze284_out1[..],
            &unsqueeze285_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape165_out1 = slice109_out1.reshape(concat182_out1);
        let transpose156_out1 = reshape159_out1.permute([0, 2, 3, 1]);
        let matmul153_out1 = transpose152_out1.matmul(transpose156_out1);
        let shape163_out1: [i64; 4] = {
            let axes = &matmul153_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice110_out1: [i64; 1] = shape163_out1[3..4].try_into().unwrap();
        let squeeze13_out1 = slice110_out1[0] as i64;
        let unsqueeze286_out1 = [squeeze13_out1 as i64];
        let slice111_out1 = reshape165_out1
            .slice(s![.., .., .., 0..unsqueeze286_out1[0]]);
        let add101_out1 = matmul153_out1.add(slice111_out1);
        let constant1814_out1 = self.constant1814.val();
        let div17_out1 = add101_out1
            .div((constant1814_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape164_out1: [i64; 4] = {
            let axes = &transpose151_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather158_out1 = shape164_out1[0] as i64;
        let constant1816_out1 = -10000f32;
        let where55_out1 = div17_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1816_out1);
        let softmax13_out1 = burn::tensor::activation::softmax(where55_out1, 3);
        let constant1817_out1 = 0f32;
        let where56_out1 = softmax13_out1
            .mask_fill(unsqueeze117_out1, constant1817_out1);
        let matmul154_out1 = where56_out1.matmul(transpose151_out1);
        let transpose157_out1 = matmul154_out1.permute([0, 2, 1, 3]);
        let unsqueeze287_out1 = [gather158_out1 as i64];
        let constant1820_out1: [i64; 1] = [512i64];
        let constant1819_out1: [i64; 1] = [-1i64];
        let concat183_out1: [i64; 3usize] = [
            &unsqueeze287_out1[..],
            &constant1819_out1[..],
            &constant1820_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape166_out1 = transpose157_out1.reshape(concat183_out1);
        let linear116_out1 = self.linear116.forward(reshape166_out1);
        let add102_out1 = add98_out1.add(linear116_out1);
        (add102_out1, gather151_out1, concat176_out1, slice105_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule18 {
    layernormalization75: LayerNorm,
    conv1d37: Conv1d,
    conv1d38: Conv1d,
    layernormalization76: LayerNorm,
    conv1d39: Conv1d,
    layernormalization77: LayerNorm,
    linear117: Linear,
    linear118: Linear,
    constant1834: burn::module::Param<Tensor<1>>,
    layernormalization78: LayerNorm,
    layernormalization79: LayerNorm,
    linear119: Linear,
    linear120: Linear,
    constant1836: burn::module::Param<Tensor<1>>,
    layernormalization80: LayerNorm,
    linear121: Linear,
    linear122: Linear,
    linear123: Linear,
    linear124: Linear,
    constant244: burn::module::Param<Tensor<2>>,
    constant245: burn::module::Param<Tensor<2>>,
    constant1891: burn::module::Param<Tensor<1>>,
    linear125: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule18 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization75 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d37 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d38 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization76 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d39 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization77 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear117 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear118 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1834: 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 layernormalization78 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization79 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear119 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear120 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1836: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear121 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear122 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear123 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear124 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant244: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant245: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear125 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization75,
            conv1d37,
            conv1d38,
            layernormalization76,
            conv1d39,
            layernormalization77,
            linear117,
            linear118,
            constant1834,
            layernormalization78,
            layernormalization79,
            linear119,
            linear120,
            constant1836,
            layernormalization80,
            linear121,
            linear122,
            linear123,
            linear124,
            constant244,
            constant245,
            constant1891,
            linear125,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add102_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather151_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization75_out1 = {
            let dtype = add102_out1.clone().dtype();
            self.layernormalization75
                .forward(add102_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose158_out1 = layernormalization75_out1.permute([0, 2, 1]);
        let conv1d37_out1 = self.conv1d37.forward(transpose158_out1);
        let split_tensors = conv1d37_out1.split_with_sizes([512, 512].into(), 1);
        let [split13_out1, split13_out2] = split_tensors.try_into().unwrap();
        let sigmoid50_out1 = burn::tensor::activation::sigmoid(split13_out2);
        let mul120_out1 = split13_out1.mul(sigmoid50_out1);
        let constant1821_out1 = 0f32;
        let where57_out1 = mul120_out1.mask_fill(unsqueeze119_out1, constant1821_out1);
        let concat185_out1 = burn::tensor::Tensor::cat(
            [gather151_out1, where57_out1].into(),
            2,
        );
        let slice113_out1 = concat185_out1.clone().slice(s![.., .., - 8..]);
        let conv1d38_out1 = self.conv1d38.forward(concat185_out1);
        let transpose160_out1 = conv1d38_out1.permute([0, 2, 1]);
        let layernormalization76_out1 = {
            let dtype = transpose160_out1.dtype();
            self.layernormalization76
                .forward(transpose160_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose161_out1 = layernormalization76_out1.permute([0, 2, 1]);
        let sigmoid51_out1 = burn::tensor::activation::sigmoid(
            transpose161_out1.clone(),
        );
        let mul121_out1 = transpose161_out1.mul(sigmoid51_out1);
        let conv1d39_out1 = self.conv1d39.forward(mul121_out1);
        let transpose162_out1 = conv1d39_out1.permute([0, 2, 1]);
        let add103_out1 = add102_out1.add(transpose162_out1);
        let layernormalization77_out1 = {
            let dtype = add103_out1.clone().dtype();
            self.layernormalization77
                .forward(add103_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear117_out1 = self.linear117.forward(layernormalization77_out1);
        let sigmoid52_out1 = burn::tensor::activation::sigmoid(linear117_out1.clone());
        let mul122_out1 = linear117_out1.mul(sigmoid52_out1);
        let linear118_out1 = self.linear118.forward(mul122_out1);
        let constant1834_out1 = self.constant1834.val();
        let mul123_out1 = linear118_out1
            .mul((constant1834_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add104_out1 = add103_out1.add(mul123_out1);
        let layernormalization78_out1 = {
            let dtype = add104_out1.dtype();
            self.layernormalization78
                .forward(add104_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather159_out1 = {
            let sliced = cache_last_channel.slice(s![13, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather160_out1 = {
            let sliced = cache_last_time.slice(s![13, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization79_out1 = {
            let dtype = layernormalization78_out1.clone().dtype();
            self.layernormalization79
                .forward(
                    layernormalization78_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear119_out1 = self.linear119.forward(layernormalization79_out1);
        let sigmoid53_out1 = burn::tensor::activation::sigmoid(linear119_out1.clone());
        let mul124_out1 = linear119_out1.mul(sigmoid53_out1);
        let linear120_out1 = self.linear120.forward(mul124_out1);
        let constant1836_out1 = self.constant1836.val();
        let mul125_out1 = linear120_out1
            .mul((constant1836_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add105_out1 = layernormalization78_out1.add(mul125_out1);
        let layernormalization80_out1 = {
            let dtype = add105_out1.clone().dtype();
            self.layernormalization80
                .forward(add105_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat186_out1 = burn::tensor::Tensor::cat(
            [gather159_out1.clone(), layernormalization80_out1.clone()].into(),
            1,
        );
        let shape165_out1: [i64; 3] = {
            let axes = &layernormalization80_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather161_out1 = shape165_out1[1] as i64;
        let unsqueeze288_out1 = [gather161_out1 as i64];
        let slice114_out1 = gather159_out1
            .slice(s![.., unsqueeze288_out1[0]..9223372036854775807, ..]);
        let unsqueeze289_out1 = [gather161_out1 as i64];
        let slice115_out1 = layernormalization80_out1
            .clone()
            .slice(s![.., 0..unsqueeze289_out1[0], ..]);
        let concat187_out1 = burn::tensor::Tensor::cat(
            [slice114_out1, slice115_out1].into(),
            1,
        );
        let gather162_out1 = shape165_out1[0] as i64;
        let linear121_out1 = self.linear121.forward(layernormalization80_out1);
        let unsqueeze290_out1 = [gather162_out1 as i64];
        let constant1850_out1: [i64; 1] = [64i64];
        let constant1848_out1: [i64; 1] = [-1i64];
        let constant1849_out1: [i64; 1] = [8i64];
        let concat188_out1: [i64; 4usize] = [
            &unsqueeze290_out1[..],
            &constant1848_out1[..],
            &constant1849_out1[..],
            &constant1850_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze291_out1 = [gather162_out1 as i64];
        let constant1854_out1: [i64; 1] = [64i64];
        let constant1852_out1: [i64; 1] = [-1i64];
        let constant1853_out1: [i64; 1] = [8i64];
        let concat189_out1: [i64; 4usize] = [
            &unsqueeze291_out1[..],
            &constant1852_out1[..],
            &constant1853_out1[..],
            &constant1854_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze292_out1 = [gather162_out1 as i64];
        let constant1858_out1: [i64; 1] = [64i64];
        let constant1856_out1: [i64; 1] = [-1i64];
        let constant1857_out1: [i64; 1] = [8i64];
        let concat190_out1: [i64; 4usize] = [
            &unsqueeze292_out1[..],
            &constant1856_out1[..],
            &constant1857_out1[..],
            &constant1858_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape169_out1 = linear121_out1.reshape(concat188_out1);
        let linear122_out1 = self.linear122.forward(concat186_out1.clone());
        let reshape170_out1 = linear122_out1.reshape(concat189_out1);
        let linear123_out1 = self.linear123.forward(concat186_out1);
        let reshape171_out1 = linear123_out1.reshape(concat190_out1);
        let transpose163_out1 = reshape171_out1.permute([0, 2, 1, 3]);
        let linear124_out1 = self.linear124.forward(slice5_out1);
        let reshape172_out1 = linear124_out1.reshape([1, -1, 8, 64]);
        let constant244_out1 = self.constant244.val();
        let add106_out1 = reshape169_out1
            .clone()
            .add((constant244_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose164_out1 = add106_out1.permute([0, 2, 1, 3]);
        let constant245_out1 = self.constant245.val();
        let add107_out1 = reshape169_out1
            .add((constant245_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose165_out1 = add107_out1.permute([0, 2, 1, 3]);
        let transpose166_out1 = reshape172_out1.permute([0, 2, 3, 1]);
        let matmul164_out1 = transpose165_out1.matmul(transpose166_out1);
        let shape167_out1: [i64; 4] = {
            let axes = &matmul164_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather163_out1 = shape167_out1[0] as i64;
        let gather164_out1 = shape167_out1[1] as i64;
        let gather165_out1 = shape167_out1[2] as i64;
        let gather166_out1 = shape167_out1[3] as i64;
        let pad30_out1 = matmul164_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze293_out1 = [gather163_out1 as i64];
        let unsqueeze294_out1 = [gather164_out1 as i64];
        let unsqueeze295_out1 = [gather165_out1 as i64];
        let constant1873_out1: [i64; 1] = [-1i64];
        let concat192_out1: [i64; 4usize] = [
            &unsqueeze293_out1[..],
            &unsqueeze294_out1[..],
            &constant1873_out1[..],
            &unsqueeze295_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape175_out1 = pad30_out1.reshape(concat192_out1);
        let slice117_out1 = reshape175_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze296_out1 = [gather163_out1 as i64];
        let unsqueeze297_out1 = [gather164_out1 as i64];
        let unsqueeze298_out1 = [gather165_out1 as i64];
        let unsqueeze299_out1 = [gather166_out1 as i64];
        let concat193_out1: [i64; 4usize] = [
            &unsqueeze296_out1[..],
            &unsqueeze297_out1[..],
            &unsqueeze298_out1[..],
            &unsqueeze299_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape176_out1 = slice117_out1.reshape(concat193_out1);
        let transpose168_out1 = reshape170_out1.permute([0, 2, 3, 1]);
        let matmul165_out1 = transpose164_out1.matmul(transpose168_out1);
        let shape171_out1: [i64; 4] = {
            let axes = &matmul165_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice118_out1: [i64; 1] = shape171_out1[3..4].try_into().unwrap();
        let squeeze14_out1 = slice118_out1[0] as i64;
        let unsqueeze300_out1 = [squeeze14_out1 as i64];
        let slice119_out1 = reshape176_out1
            .slice(s![.., .., .., 0..unsqueeze300_out1[0]]);
        let add108_out1 = matmul165_out1.add(slice119_out1);
        let constant1891_out1 = self.constant1891.val();
        let div18_out1 = add108_out1
            .div((constant1891_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape172_out1: [i64; 4] = {
            let axes = &transpose163_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather167_out1 = shape172_out1[0] as i64;
        let constant1893_out1 = -10000f32;
        let where58_out1 = div18_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1893_out1);
        let softmax14_out1 = burn::tensor::activation::softmax(where58_out1, 3);
        let constant1894_out1 = 0f32;
        let where59_out1 = softmax14_out1
            .mask_fill(unsqueeze117_out1, constant1894_out1);
        let matmul166_out1 = where59_out1.matmul(transpose163_out1);
        let transpose169_out1 = matmul166_out1.permute([0, 2, 1, 3]);
        let unsqueeze301_out1 = [gather167_out1 as i64];
        let constant1897_out1: [i64; 1] = [512i64];
        let constant1896_out1: [i64; 1] = [-1i64];
        let concat194_out1: [i64; 3usize] = [
            &unsqueeze301_out1[..],
            &constant1896_out1[..],
            &constant1897_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape177_out1 = transpose169_out1.reshape(concat194_out1);
        let linear125_out1 = self.linear125.forward(reshape177_out1);
        let add109_out1 = add105_out1.add(linear125_out1);
        (add109_out1, gather160_out1, concat187_out1, slice113_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule19 {
    layernormalization81: LayerNorm,
    conv1d40: Conv1d,
    conv1d41: Conv1d,
    layernormalization82: LayerNorm,
    conv1d42: Conv1d,
    layernormalization83: LayerNorm,
    linear126: Linear,
    linear127: Linear,
    constant1911: burn::module::Param<Tensor<1>>,
    layernormalization84: LayerNorm,
    layernormalization85: LayerNorm,
    linear128: Linear,
    linear129: Linear,
    constant1913: burn::module::Param<Tensor<1>>,
    layernormalization86: LayerNorm,
    linear130: Linear,
    linear131: Linear,
    linear132: Linear,
    linear133: Linear,
    constant261: burn::module::Param<Tensor<2>>,
    constant262: burn::module::Param<Tensor<2>>,
    constant1968: burn::module::Param<Tensor<1>>,
    linear134: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule19 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization81 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d40 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d41 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization82 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d42 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization83 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear126 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear127 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1911: 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 layernormalization84 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization85 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear128 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear129 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1913: 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 layernormalization86 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear130 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear131 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear132 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear133 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant261: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant262: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant1968: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear134 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization81,
            conv1d40,
            conv1d41,
            layernormalization82,
            conv1d42,
            layernormalization83,
            linear126,
            linear127,
            constant1911,
            layernormalization84,
            layernormalization85,
            linear128,
            linear129,
            constant1913,
            layernormalization86,
            linear130,
            linear131,
            linear132,
            linear133,
            constant261,
            constant262,
            constant1968,
            linear134,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add109_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather160_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization81_out1 = {
            let dtype = add109_out1.clone().dtype();
            self.layernormalization81
                .forward(add109_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose170_out1 = layernormalization81_out1.permute([0, 2, 1]);
        let conv1d40_out1 = self.conv1d40.forward(transpose170_out1);
        let split_tensors = conv1d40_out1.split_with_sizes([512, 512].into(), 1);
        let [split14_out1, split14_out2] = split_tensors.try_into().unwrap();
        let sigmoid54_out1 = burn::tensor::activation::sigmoid(split14_out2);
        let mul126_out1 = split14_out1.mul(sigmoid54_out1);
        let constant1898_out1 = 0f32;
        let where60_out1 = mul126_out1.mask_fill(unsqueeze119_out1, constant1898_out1);
        let concat196_out1 = burn::tensor::Tensor::cat(
            [gather160_out1, where60_out1].into(),
            2,
        );
        let slice121_out1 = concat196_out1.clone().slice(s![.., .., - 8..]);
        let conv1d41_out1 = self.conv1d41.forward(concat196_out1);
        let transpose172_out1 = conv1d41_out1.permute([0, 2, 1]);
        let layernormalization82_out1 = {
            let dtype = transpose172_out1.dtype();
            self.layernormalization82
                .forward(transpose172_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose173_out1 = layernormalization82_out1.permute([0, 2, 1]);
        let sigmoid55_out1 = burn::tensor::activation::sigmoid(
            transpose173_out1.clone(),
        );
        let mul127_out1 = transpose173_out1.mul(sigmoid55_out1);
        let conv1d42_out1 = self.conv1d42.forward(mul127_out1);
        let transpose174_out1 = conv1d42_out1.permute([0, 2, 1]);
        let add110_out1 = add109_out1.add(transpose174_out1);
        let layernormalization83_out1 = {
            let dtype = add110_out1.clone().dtype();
            self.layernormalization83
                .forward(add110_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear126_out1 = self.linear126.forward(layernormalization83_out1);
        let sigmoid56_out1 = burn::tensor::activation::sigmoid(linear126_out1.clone());
        let mul128_out1 = linear126_out1.mul(sigmoid56_out1);
        let linear127_out1 = self.linear127.forward(mul128_out1);
        let constant1911_out1 = self.constant1911.val();
        let mul129_out1 = linear127_out1
            .mul((constant1911_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add111_out1 = add110_out1.add(mul129_out1);
        let layernormalization84_out1 = {
            let dtype = add111_out1.dtype();
            self.layernormalization84
                .forward(add111_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather168_out1 = {
            let sliced = cache_last_channel.slice(s![14, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather169_out1 = {
            let sliced = cache_last_time.slice(s![14, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization85_out1 = {
            let dtype = layernormalization84_out1.clone().dtype();
            self.layernormalization85
                .forward(
                    layernormalization84_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear128_out1 = self.linear128.forward(layernormalization85_out1);
        let sigmoid57_out1 = burn::tensor::activation::sigmoid(linear128_out1.clone());
        let mul130_out1 = linear128_out1.mul(sigmoid57_out1);
        let linear129_out1 = self.linear129.forward(mul130_out1);
        let constant1913_out1 = self.constant1913.val();
        let mul131_out1 = linear129_out1
            .mul((constant1913_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add112_out1 = layernormalization84_out1.add(mul131_out1);
        let layernormalization86_out1 = {
            let dtype = add112_out1.clone().dtype();
            self.layernormalization86
                .forward(add112_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat197_out1 = burn::tensor::Tensor::cat(
            [gather168_out1.clone(), layernormalization86_out1.clone()].into(),
            1,
        );
        let shape173_out1: [i64; 3] = {
            let axes = &layernormalization86_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather170_out1 = shape173_out1[1] as i64;
        let unsqueeze302_out1 = [gather170_out1 as i64];
        let slice122_out1 = gather168_out1
            .slice(s![.., unsqueeze302_out1[0]..9223372036854775807, ..]);
        let unsqueeze303_out1 = [gather170_out1 as i64];
        let slice123_out1 = layernormalization86_out1
            .clone()
            .slice(s![.., 0..unsqueeze303_out1[0], ..]);
        let concat198_out1 = burn::tensor::Tensor::cat(
            [slice122_out1, slice123_out1].into(),
            1,
        );
        let gather171_out1 = shape173_out1[0] as i64;
        let linear130_out1 = self.linear130.forward(layernormalization86_out1);
        let unsqueeze304_out1 = [gather171_out1 as i64];
        let constant1927_out1: [i64; 1] = [64i64];
        let constant1925_out1: [i64; 1] = [-1i64];
        let constant1926_out1: [i64; 1] = [8i64];
        let concat199_out1: [i64; 4usize] = [
            &unsqueeze304_out1[..],
            &constant1925_out1[..],
            &constant1926_out1[..],
            &constant1927_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze305_out1 = [gather171_out1 as i64];
        let constant1931_out1: [i64; 1] = [64i64];
        let constant1929_out1: [i64; 1] = [-1i64];
        let constant1930_out1: [i64; 1] = [8i64];
        let concat200_out1: [i64; 4usize] = [
            &unsqueeze305_out1[..],
            &constant1929_out1[..],
            &constant1930_out1[..],
            &constant1931_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze306_out1 = [gather171_out1 as i64];
        let constant1935_out1: [i64; 1] = [64i64];
        let constant1933_out1: [i64; 1] = [-1i64];
        let constant1934_out1: [i64; 1] = [8i64];
        let concat201_out1: [i64; 4usize] = [
            &unsqueeze306_out1[..],
            &constant1933_out1[..],
            &constant1934_out1[..],
            &constant1935_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape180_out1 = linear130_out1.reshape(concat199_out1);
        let linear131_out1 = self.linear131.forward(concat197_out1.clone());
        let reshape181_out1 = linear131_out1.reshape(concat200_out1);
        let linear132_out1 = self.linear132.forward(concat197_out1);
        let reshape182_out1 = linear132_out1.reshape(concat201_out1);
        let transpose175_out1 = reshape182_out1.permute([0, 2, 1, 3]);
        let linear133_out1 = self.linear133.forward(slice5_out1);
        let reshape183_out1 = linear133_out1.reshape([1, -1, 8, 64]);
        let constant261_out1 = self.constant261.val();
        let add113_out1 = reshape180_out1
            .clone()
            .add((constant261_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose176_out1 = add113_out1.permute([0, 2, 1, 3]);
        let constant262_out1 = self.constant262.val();
        let add114_out1 = reshape180_out1
            .add((constant262_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose177_out1 = add114_out1.permute([0, 2, 1, 3]);
        let transpose178_out1 = reshape183_out1.permute([0, 2, 3, 1]);
        let matmul176_out1 = transpose177_out1.matmul(transpose178_out1);
        let shape175_out1: [i64; 4] = {
            let axes = &matmul176_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather172_out1 = shape175_out1[0] as i64;
        let gather173_out1 = shape175_out1[1] as i64;
        let gather174_out1 = shape175_out1[2] as i64;
        let gather175_out1 = shape175_out1[3] as i64;
        let pad32_out1 = matmul176_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze307_out1 = [gather172_out1 as i64];
        let unsqueeze308_out1 = [gather173_out1 as i64];
        let unsqueeze309_out1 = [gather174_out1 as i64];
        let constant1950_out1: [i64; 1] = [-1i64];
        let concat203_out1: [i64; 4usize] = [
            &unsqueeze307_out1[..],
            &unsqueeze308_out1[..],
            &constant1950_out1[..],
            &unsqueeze309_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape186_out1 = pad32_out1.reshape(concat203_out1);
        let slice125_out1 = reshape186_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze310_out1 = [gather172_out1 as i64];
        let unsqueeze311_out1 = [gather173_out1 as i64];
        let unsqueeze312_out1 = [gather174_out1 as i64];
        let unsqueeze313_out1 = [gather175_out1 as i64];
        let concat204_out1: [i64; 4usize] = [
            &unsqueeze310_out1[..],
            &unsqueeze311_out1[..],
            &unsqueeze312_out1[..],
            &unsqueeze313_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape187_out1 = slice125_out1.reshape(concat204_out1);
        let transpose180_out1 = reshape181_out1.permute([0, 2, 3, 1]);
        let matmul177_out1 = transpose176_out1.matmul(transpose180_out1);
        let shape179_out1: [i64; 4] = {
            let axes = &matmul177_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice126_out1: [i64; 1] = shape179_out1[3..4].try_into().unwrap();
        let squeeze15_out1 = slice126_out1[0] as i64;
        let unsqueeze314_out1 = [squeeze15_out1 as i64];
        let slice127_out1 = reshape187_out1
            .slice(s![.., .., .., 0..unsqueeze314_out1[0]]);
        let add115_out1 = matmul177_out1.add(slice127_out1);
        let constant1968_out1 = self.constant1968.val();
        let div19_out1 = add115_out1
            .div((constant1968_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape180_out1: [i64; 4] = {
            let axes = &transpose175_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather176_out1 = shape180_out1[0] as i64;
        let constant1970_out1 = -10000f32;
        let where61_out1 = div19_out1
            .mask_fill(unsqueeze117_out1.clone(), constant1970_out1);
        let softmax15_out1 = burn::tensor::activation::softmax(where61_out1, 3);
        let constant1971_out1 = 0f32;
        let where62_out1 = softmax15_out1
            .mask_fill(unsqueeze117_out1, constant1971_out1);
        let matmul178_out1 = where62_out1.matmul(transpose175_out1);
        let transpose181_out1 = matmul178_out1.permute([0, 2, 1, 3]);
        let unsqueeze315_out1 = [gather176_out1 as i64];
        let constant1974_out1: [i64; 1] = [512i64];
        let constant1973_out1: [i64; 1] = [-1i64];
        let concat205_out1: [i64; 3usize] = [
            &unsqueeze315_out1[..],
            &constant1973_out1[..],
            &constant1974_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape188_out1 = transpose181_out1.reshape(concat205_out1);
        let linear134_out1 = self.linear134.forward(reshape188_out1);
        let add116_out1 = add112_out1.add(linear134_out1);
        (add116_out1, gather169_out1, concat198_out1, slice121_out1)
    }
}
#[derive(Module, Debug)]
pub struct Submodule20 {
    layernormalization87: LayerNorm,
    conv1d43: Conv1d,
    conv1d44: Conv1d,
    layernormalization88: LayerNorm,
    conv1d45: Conv1d,
    layernormalization89: LayerNorm,
    linear135: Linear,
    linear136: Linear,
    constant1988: burn::module::Param<Tensor<1>>,
    layernormalization90: LayerNorm,
    layernormalization91: LayerNorm,
    linear137: Linear,
    linear138: Linear,
    constant1990: burn::module::Param<Tensor<1>>,
    layernormalization92: LayerNorm,
    linear139: Linear,
    linear140: Linear,
    linear141: Linear,
    linear142: Linear,
    constant278: burn::module::Param<Tensor<2>>,
    constant279: burn::module::Param<Tensor<2>>,
    constant2045: burn::module::Param<Tensor<1>>,
    linear143: Linear,
    layernormalization93: LayerNorm,
    conv1d46: Conv1d,
    conv1d47: Conv1d,
    layernormalization94: LayerNorm,
    conv1d48: Conv1d,
    layernormalization95: LayerNorm,
    linear144: Linear,
    linear145: Linear,
    constant2065: burn::module::Param<Tensor<1>>,
    layernormalization96: LayerNorm,
    layernormalization97: LayerNorm,
    linear146: Linear,
    linear147: Linear,
    constant2067: burn::module::Param<Tensor<1>>,
    layernormalization98: LayerNorm,
    linear148: Linear,
    linear149: Linear,
    linear150: Linear,
    linear151: Linear,
    constant295: burn::module::Param<Tensor<2>>,
    constant296: burn::module::Param<Tensor<2>>,
    constant2122: burn::module::Param<Tensor<1>>,
    linear152: Linear,
    #[module(skip)]
    device: Device,
}
impl Submodule20 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization87 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d43 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d44 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization88 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d45 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization89 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear135 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear136 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1988: 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 layernormalization90 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization91 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear137 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear138 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant1990: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear139 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear140 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear141 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear142 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant278: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant279: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear143 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let layernormalization93 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d46 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d47 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization94 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d48 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization95 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear144 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear145 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant2065: 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 layernormalization96 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let layernormalization97 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear146 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear147 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant2067: 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 layernormalization98 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear148 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear149 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear150 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let linear151 = LinearConfig::new(512, 512).with_bias(false).init(device);
        let constant295: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant296: burn::module::Param<Tensor<2>> = burn::module::Param::uninitialized(
            burn::module::ParamId::new(),
            move |device, _require_grad| Tensor::<
                2,
            >::zeros([8, 64], (device, burn::tensor::DType::F32)),
            device.clone(),
            false,
            [8, 64].into(),
        );
        let constant2122: 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([8f64]),
                (device, burn::tensor::DType::F32),
            ),
            device.clone(),
            false,
            [1].into(),
        );
        let linear152 = LinearConfig::new(512, 512).with_bias(false).init(device);
        Self {
            layernormalization87,
            conv1d43,
            conv1d44,
            layernormalization88,
            conv1d45,
            layernormalization89,
            linear135,
            linear136,
            constant1988,
            layernormalization90,
            layernormalization91,
            linear137,
            linear138,
            constant1990,
            layernormalization92,
            linear139,
            linear140,
            linear141,
            linear142,
            constant278,
            constant279,
            constant2045,
            linear143,
            layernormalization93,
            conv1d46,
            conv1d47,
            layernormalization94,
            conv1d48,
            layernormalization95,
            linear144,
            linear145,
            constant2065,
            layernormalization96,
            layernormalization97,
            linear146,
            linear147,
            constant2067,
            layernormalization98,
            linear148,
            linear149,
            linear150,
            linear151,
            constant295,
            constant296,
            constant2122,
            linear152,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add116_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather169_out1: Tensor<3>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        slice5_out1: Tensor<3>,
        unsqueeze117_out1: Tensor<4, Bool>,
    ) -> (Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>, Tensor<3>) {
        let layernormalization87_out1 = {
            let dtype = add116_out1.clone().dtype();
            self.layernormalization87
                .forward(add116_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose182_out1 = layernormalization87_out1.permute([0, 2, 1]);
        let conv1d43_out1 = self.conv1d43.forward(transpose182_out1);
        let split_tensors = conv1d43_out1.split_with_sizes([512, 512].into(), 1);
        let [split15_out1, split15_out2] = split_tensors.try_into().unwrap();
        let sigmoid58_out1 = burn::tensor::activation::sigmoid(split15_out2);
        let mul132_out1 = split15_out1.mul(sigmoid58_out1);
        let constant1975_out1 = 0f32;
        let where63_out1 = mul132_out1
            .mask_fill(unsqueeze119_out1.clone(), constant1975_out1);
        let concat207_out1 = burn::tensor::Tensor::cat(
            [gather169_out1, where63_out1].into(),
            2,
        );
        let slice129_out1 = concat207_out1.clone().slice(s![.., .., - 8..]);
        let conv1d44_out1 = self.conv1d44.forward(concat207_out1);
        let transpose184_out1 = conv1d44_out1.permute([0, 2, 1]);
        let layernormalization88_out1 = {
            let dtype = transpose184_out1.dtype();
            self.layernormalization88
                .forward(transpose184_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose185_out1 = layernormalization88_out1.permute([0, 2, 1]);
        let sigmoid59_out1 = burn::tensor::activation::sigmoid(
            transpose185_out1.clone(),
        );
        let mul133_out1 = transpose185_out1.mul(sigmoid59_out1);
        let conv1d45_out1 = self.conv1d45.forward(mul133_out1);
        let transpose186_out1 = conv1d45_out1.permute([0, 2, 1]);
        let add117_out1 = add116_out1.add(transpose186_out1);
        let layernormalization89_out1 = {
            let dtype = add117_out1.clone().dtype();
            self.layernormalization89
                .forward(add117_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear135_out1 = self.linear135.forward(layernormalization89_out1);
        let sigmoid60_out1 = burn::tensor::activation::sigmoid(linear135_out1.clone());
        let mul134_out1 = linear135_out1.mul(sigmoid60_out1);
        let linear136_out1 = self.linear136.forward(mul134_out1);
        let constant1988_out1 = self.constant1988.val();
        let mul135_out1 = linear136_out1
            .mul((constant1988_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add118_out1 = add117_out1.add(mul135_out1);
        let layernormalization90_out1 = {
            let dtype = add118_out1.dtype();
            self.layernormalization90
                .forward(add118_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather177_out1 = {
            let sliced = cache_last_channel.clone().slice(s![15, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather178_out1 = {
            let sliced = cache_last_time.clone().slice(s![15, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization91_out1 = {
            let dtype = layernormalization90_out1.clone().dtype();
            self.layernormalization91
                .forward(
                    layernormalization90_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear137_out1 = self.linear137.forward(layernormalization91_out1);
        let sigmoid61_out1 = burn::tensor::activation::sigmoid(linear137_out1.clone());
        let mul136_out1 = linear137_out1.mul(sigmoid61_out1);
        let linear138_out1 = self.linear138.forward(mul136_out1);
        let constant1990_out1 = self.constant1990.val();
        let mul137_out1 = linear138_out1
            .mul((constant1990_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add119_out1 = layernormalization90_out1.add(mul137_out1);
        let layernormalization92_out1 = {
            let dtype = add119_out1.clone().dtype();
            self.layernormalization92
                .forward(add119_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat208_out1 = burn::tensor::Tensor::cat(
            [gather177_out1.clone(), layernormalization92_out1.clone()].into(),
            1,
        );
        let shape181_out1: [i64; 3] = {
            let axes = &layernormalization92_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather179_out1 = shape181_out1[1] as i64;
        let unsqueeze316_out1 = [gather179_out1 as i64];
        let slice130_out1 = gather177_out1
            .slice(s![.., unsqueeze316_out1[0]..9223372036854775807, ..]);
        let unsqueeze317_out1 = [gather179_out1 as i64];
        let slice131_out1 = layernormalization92_out1
            .clone()
            .slice(s![.., 0..unsqueeze317_out1[0], ..]);
        let concat209_out1 = burn::tensor::Tensor::cat(
            [slice130_out1, slice131_out1].into(),
            1,
        );
        let gather180_out1 = shape181_out1[0] as i64;
        let linear139_out1 = self.linear139.forward(layernormalization92_out1);
        let unsqueeze318_out1 = [gather180_out1 as i64];
        let constant2004_out1: [i64; 1] = [64i64];
        let constant2002_out1: [i64; 1] = [-1i64];
        let constant2003_out1: [i64; 1] = [8i64];
        let concat210_out1: [i64; 4usize] = [
            &unsqueeze318_out1[..],
            &constant2002_out1[..],
            &constant2003_out1[..],
            &constant2004_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze319_out1 = [gather180_out1 as i64];
        let constant2008_out1: [i64; 1] = [64i64];
        let constant2006_out1: [i64; 1] = [-1i64];
        let constant2007_out1: [i64; 1] = [8i64];
        let concat211_out1: [i64; 4usize] = [
            &unsqueeze319_out1[..],
            &constant2006_out1[..],
            &constant2007_out1[..],
            &constant2008_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze320_out1 = [gather180_out1 as i64];
        let constant2012_out1: [i64; 1] = [64i64];
        let constant2010_out1: [i64; 1] = [-1i64];
        let constant2011_out1: [i64; 1] = [8i64];
        let concat212_out1: [i64; 4usize] = [
            &unsqueeze320_out1[..],
            &constant2010_out1[..],
            &constant2011_out1[..],
            &constant2012_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape191_out1 = linear139_out1.reshape(concat210_out1);
        let linear140_out1 = self.linear140.forward(concat208_out1.clone());
        let reshape192_out1 = linear140_out1.reshape(concat211_out1);
        let linear141_out1 = self.linear141.forward(concat208_out1);
        let reshape193_out1 = linear141_out1.reshape(concat212_out1);
        let transpose187_out1 = reshape193_out1.permute([0, 2, 1, 3]);
        let linear142_out1 = self.linear142.forward(slice5_out1.clone());
        let reshape194_out1 = linear142_out1.reshape([1, -1, 8, 64]);
        let constant278_out1 = self.constant278.val();
        let add120_out1 = reshape191_out1
            .clone()
            .add((constant278_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose188_out1 = add120_out1.permute([0, 2, 1, 3]);
        let constant279_out1 = self.constant279.val();
        let add121_out1 = reshape191_out1
            .add((constant279_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose189_out1 = add121_out1.permute([0, 2, 1, 3]);
        let transpose190_out1 = reshape194_out1.permute([0, 2, 3, 1]);
        let matmul188_out1 = transpose189_out1.matmul(transpose190_out1);
        let shape183_out1: [i64; 4] = {
            let axes = &matmul188_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather181_out1 = shape183_out1[0] as i64;
        let gather182_out1 = shape183_out1[1] as i64;
        let gather183_out1 = shape183_out1[2] as i64;
        let gather184_out1 = shape183_out1[3] as i64;
        let pad34_out1 = matmul188_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze321_out1 = [gather181_out1 as i64];
        let unsqueeze322_out1 = [gather182_out1 as i64];
        let unsqueeze323_out1 = [gather183_out1 as i64];
        let constant2027_out1: [i64; 1] = [-1i64];
        let concat214_out1: [i64; 4usize] = [
            &unsqueeze321_out1[..],
            &unsqueeze322_out1[..],
            &constant2027_out1[..],
            &unsqueeze323_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape197_out1 = pad34_out1.reshape(concat214_out1);
        let slice133_out1 = reshape197_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze324_out1 = [gather181_out1 as i64];
        let unsqueeze325_out1 = [gather182_out1 as i64];
        let unsqueeze326_out1 = [gather183_out1 as i64];
        let unsqueeze327_out1 = [gather184_out1 as i64];
        let concat215_out1: [i64; 4usize] = [
            &unsqueeze324_out1[..],
            &unsqueeze325_out1[..],
            &unsqueeze326_out1[..],
            &unsqueeze327_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape198_out1 = slice133_out1.reshape(concat215_out1);
        let transpose192_out1 = reshape192_out1.permute([0, 2, 3, 1]);
        let matmul189_out1 = transpose188_out1.matmul(transpose192_out1);
        let shape187_out1: [i64; 4] = {
            let axes = &matmul189_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice134_out1: [i64; 1] = shape187_out1[3..4].try_into().unwrap();
        let squeeze16_out1 = slice134_out1[0] as i64;
        let unsqueeze328_out1 = [squeeze16_out1 as i64];
        let slice135_out1 = reshape198_out1
            .slice(s![.., .., .., 0..unsqueeze328_out1[0]]);
        let add122_out1 = matmul189_out1.add(slice135_out1);
        let constant2045_out1 = self.constant2045.val();
        let div20_out1 = add122_out1
            .div((constant2045_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape188_out1: [i64; 4] = {
            let axes = &transpose187_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather185_out1 = shape188_out1[0] as i64;
        let constant2047_out1 = -10000f32;
        let where64_out1 = div20_out1
            .mask_fill(unsqueeze117_out1.clone(), constant2047_out1);
        let softmax16_out1 = burn::tensor::activation::softmax(where64_out1, 3);
        let constant2048_out1 = 0f32;
        let where65_out1 = softmax16_out1
            .mask_fill(unsqueeze117_out1.clone(), constant2048_out1);
        let matmul190_out1 = where65_out1.matmul(transpose187_out1);
        let transpose193_out1 = matmul190_out1.permute([0, 2, 1, 3]);
        let unsqueeze329_out1 = [gather185_out1 as i64];
        let constant2051_out1: [i64; 1] = [512i64];
        let constant2050_out1: [i64; 1] = [-1i64];
        let concat216_out1: [i64; 3usize] = [
            &unsqueeze329_out1[..],
            &constant2050_out1[..],
            &constant2051_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape199_out1 = transpose193_out1.reshape(concat216_out1);
        let linear143_out1 = self.linear143.forward(reshape199_out1);
        let add123_out1 = add119_out1.add(linear143_out1);
        let layernormalization93_out1 = {
            let dtype = add123_out1.clone().dtype();
            self.layernormalization93
                .forward(add123_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose194_out1 = layernormalization93_out1.permute([0, 2, 1]);
        let conv1d46_out1 = self.conv1d46.forward(transpose194_out1);
        let split_tensors = conv1d46_out1.split_with_sizes([512, 512].into(), 1);
        let [split16_out1, split16_out2] = split_tensors.try_into().unwrap();
        let sigmoid62_out1 = burn::tensor::activation::sigmoid(split16_out2);
        let mul138_out1 = split16_out1.mul(sigmoid62_out1);
        let constant2052_out1 = 0f32;
        let where66_out1 = mul138_out1.mask_fill(unsqueeze119_out1, constant2052_out1);
        let concat218_out1 = burn::tensor::Tensor::cat(
            [gather178_out1, where66_out1].into(),
            2,
        );
        let slice137_out1 = concat218_out1.clone().slice(s![.., .., - 8..]);
        let conv1d47_out1 = self.conv1d47.forward(concat218_out1);
        let transpose196_out1 = conv1d47_out1.permute([0, 2, 1]);
        let layernormalization94_out1 = {
            let dtype = transpose196_out1.dtype();
            self.layernormalization94
                .forward(transpose196_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose197_out1 = layernormalization94_out1.permute([0, 2, 1]);
        let sigmoid63_out1 = burn::tensor::activation::sigmoid(
            transpose197_out1.clone(),
        );
        let mul139_out1 = transpose197_out1.mul(sigmoid63_out1);
        let conv1d48_out1 = self.conv1d48.forward(mul139_out1);
        let transpose198_out1 = conv1d48_out1.permute([0, 2, 1]);
        let add124_out1 = add123_out1.add(transpose198_out1);
        let layernormalization95_out1 = {
            let dtype = add124_out1.clone().dtype();
            self.layernormalization95
                .forward(add124_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear144_out1 = self.linear144.forward(layernormalization95_out1);
        let sigmoid64_out1 = burn::tensor::activation::sigmoid(linear144_out1.clone());
        let mul140_out1 = linear144_out1.mul(sigmoid64_out1);
        let linear145_out1 = self.linear145.forward(mul140_out1);
        let constant2065_out1 = self.constant2065.val();
        let mul141_out1 = linear145_out1
            .mul((constant2065_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add125_out1 = add124_out1.add(mul141_out1);
        let layernormalization96_out1 = {
            let dtype = add125_out1.dtype();
            self.layernormalization96
                .forward(add125_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let gather186_out1 = {
            let sliced = cache_last_channel.slice(s![16, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let gather187_out1 = {
            let sliced = cache_last_time.slice(s![16, .., .., ..]);
            sliced.squeeze_dim::<3usize>(0)
        };
        let layernormalization97_out1 = {
            let dtype = layernormalization96_out1.clone().dtype();
            self.layernormalization97
                .forward(
                    layernormalization96_out1.clone().cast(burn::tensor::DType::F32),
                )
                .cast(dtype)
        };
        let linear146_out1 = self.linear146.forward(layernormalization97_out1);
        let sigmoid65_out1 = burn::tensor::activation::sigmoid(linear146_out1.clone());
        let mul142_out1 = linear146_out1.mul(sigmoid65_out1);
        let linear147_out1 = self.linear147.forward(mul142_out1);
        let constant2067_out1 = self.constant2067.val();
        let mul143_out1 = linear147_out1
            .mul((constant2067_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add126_out1 = layernormalization96_out1.add(mul143_out1);
        let layernormalization98_out1 = {
            let dtype = add126_out1.clone().dtype();
            self.layernormalization98
                .forward(add126_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let concat219_out1 = burn::tensor::Tensor::cat(
            [gather186_out1.clone(), layernormalization98_out1.clone()].into(),
            1,
        );
        let shape189_out1: [i64; 3] = {
            let axes = &layernormalization98_out1.clone().dims()[0..3];
            let mut output = [0i64; 3];
            for i in 0..3 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather188_out1 = shape189_out1[1] as i64;
        let unsqueeze330_out1 = [gather188_out1 as i64];
        let slice138_out1 = gather186_out1
            .slice(s![.., unsqueeze330_out1[0]..9223372036854775807, ..]);
        let unsqueeze331_out1 = [gather188_out1 as i64];
        let slice139_out1 = layernormalization98_out1
            .clone()
            .slice(s![.., 0..unsqueeze331_out1[0], ..]);
        let concat220_out1 = burn::tensor::Tensor::cat(
            [slice138_out1, slice139_out1].into(),
            1,
        );
        let gather189_out1 = shape189_out1[0] as i64;
        let linear148_out1 = self.linear148.forward(layernormalization98_out1);
        let unsqueeze332_out1 = [gather189_out1 as i64];
        let constant2081_out1: [i64; 1] = [64i64];
        let constant2079_out1: [i64; 1] = [-1i64];
        let constant2080_out1: [i64; 1] = [8i64];
        let concat221_out1: [i64; 4usize] = [
            &unsqueeze332_out1[..],
            &constant2079_out1[..],
            &constant2080_out1[..],
            &constant2081_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze333_out1 = [gather189_out1 as i64];
        let constant2085_out1: [i64; 1] = [64i64];
        let constant2083_out1: [i64; 1] = [-1i64];
        let constant2084_out1: [i64; 1] = [8i64];
        let concat222_out1: [i64; 4usize] = [
            &unsqueeze333_out1[..],
            &constant2083_out1[..],
            &constant2084_out1[..],
            &constant2085_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let unsqueeze334_out1 = [gather189_out1 as i64];
        let constant2089_out1: [i64; 1] = [64i64];
        let constant2087_out1: [i64; 1] = [-1i64];
        let constant2088_out1: [i64; 1] = [8i64];
        let concat223_out1: [i64; 4usize] = [
            &unsqueeze334_out1[..],
            &constant2087_out1[..],
            &constant2088_out1[..],
            &constant2089_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape202_out1 = linear148_out1.reshape(concat221_out1);
        let linear149_out1 = self.linear149.forward(concat219_out1.clone());
        let reshape203_out1 = linear149_out1.reshape(concat222_out1);
        let linear150_out1 = self.linear150.forward(concat219_out1);
        let reshape204_out1 = linear150_out1.reshape(concat223_out1);
        let transpose199_out1 = reshape204_out1.permute([0, 2, 1, 3]);
        let linear151_out1 = self.linear151.forward(slice5_out1);
        let reshape205_out1 = linear151_out1.reshape([1, -1, 8, 64]);
        let constant295_out1 = self.constant295.val();
        let add127_out1 = reshape202_out1
            .clone()
            .add((constant295_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose200_out1 = add127_out1.permute([0, 2, 1, 3]);
        let constant296_out1 = self.constant296.val();
        let add128_out1 = reshape202_out1
            .add((constant296_out1).unsqueeze_dims(&[0isize, 1isize]));
        let transpose201_out1 = add128_out1.permute([0, 2, 1, 3]);
        let transpose202_out1 = reshape205_out1.permute([0, 2, 3, 1]);
        let matmul200_out1 = transpose201_out1.matmul(transpose202_out1);
        let shape191_out1: [i64; 4] = {
            let axes = &matmul200_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather190_out1 = shape191_out1[0] as i64;
        let gather191_out1 = shape191_out1[1] as i64;
        let gather192_out1 = shape191_out1[2] as i64;
        let gather193_out1 = shape191_out1[3] as i64;
        let pad36_out1 = matmul200_out1
            .pad(
                [(0usize, 0usize), (0usize, 0usize), (0usize, 0usize), (1usize, 0usize)],
                burn::tensor::ops::PadMode::Constant(0f32),
            );
        let unsqueeze335_out1 = [gather190_out1 as i64];
        let unsqueeze336_out1 = [gather191_out1 as i64];
        let unsqueeze337_out1 = [gather192_out1 as i64];
        let constant2104_out1: [i64; 1] = [-1i64];
        let concat225_out1: [i64; 4usize] = [
            &unsqueeze335_out1[..],
            &unsqueeze336_out1[..],
            &constant2104_out1[..],
            &unsqueeze337_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape208_out1 = pad36_out1.reshape(concat225_out1);
        let slice141_out1 = reshape208_out1.slice(s![.., .., 1.., ..]);
        let unsqueeze338_out1 = [gather190_out1 as i64];
        let unsqueeze339_out1 = [gather191_out1 as i64];
        let unsqueeze340_out1 = [gather192_out1 as i64];
        let unsqueeze341_out1 = [gather193_out1 as i64];
        let concat226_out1: [i64; 4usize] = [
            &unsqueeze338_out1[..],
            &unsqueeze339_out1[..],
            &unsqueeze340_out1[..],
            &unsqueeze341_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape209_out1 = slice141_out1.reshape(concat226_out1);
        let transpose204_out1 = reshape203_out1.permute([0, 2, 3, 1]);
        let matmul201_out1 = transpose200_out1.matmul(transpose204_out1);
        let shape195_out1: [i64; 4] = {
            let axes = &matmul201_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let slice142_out1: [i64; 1] = shape195_out1[3..4].try_into().unwrap();
        let squeeze17_out1 = slice142_out1[0] as i64;
        let unsqueeze342_out1 = [squeeze17_out1 as i64];
        let slice143_out1 = reshape209_out1
            .slice(s![.., .., .., 0..unsqueeze342_out1[0]]);
        let add129_out1 = matmul201_out1.add(slice143_out1);
        let constant2122_out1 = self.constant2122.val();
        let div21_out1 = add129_out1
            .div((constant2122_out1).unsqueeze_dims(&[0isize, 1isize, 2isize]));
        let shape196_out1: [i64; 4] = {
            let axes = &transpose199_out1.clone().dims()[0..4];
            let mut output = [0i64; 4];
            for i in 0..4 {
                output[i] = axes[i] as i64;
            }
            output
        };
        let gather194_out1 = shape196_out1[0] as i64;
        let constant2124_out1 = -10000f32;
        let where67_out1 = div21_out1
            .mask_fill(unsqueeze117_out1.clone(), constant2124_out1);
        let softmax17_out1 = burn::tensor::activation::softmax(where67_out1, 3);
        let constant2125_out1 = 0f32;
        let where68_out1 = softmax17_out1
            .mask_fill(unsqueeze117_out1, constant2125_out1);
        let matmul202_out1 = where68_out1.matmul(transpose199_out1);
        let transpose205_out1 = matmul202_out1.permute([0, 2, 1, 3]);
        let unsqueeze343_out1 = [gather194_out1 as i64];
        let constant2128_out1: [i64; 1] = [512i64];
        let constant2127_out1: [i64; 1] = [-1i64];
        let concat227_out1: [i64; 3usize] = [
            &unsqueeze343_out1[..],
            &constant2127_out1[..],
            &constant2128_out1[..],
        ]
            .concat()
            .try_into()
            .unwrap();
        let reshape210_out1 = transpose205_out1.reshape(concat227_out1);
        let linear152_out1 = self.linear152.forward(reshape210_out1);
        let add130_out1 = add126_out1.add(linear152_out1);
        (
            add130_out1,
            gather187_out1,
            concat209_out1,
            concat220_out1,
            slice129_out1,
            slice137_out1,
        )
    }
}
#[derive(Module, Debug)]
pub struct Submodule21 {
    layernormalization99: LayerNorm,
    conv1d49: Conv1d,
    conv1d50: Conv1d,
    layernormalization100: LayerNorm,
    conv1d51: Conv1d,
    layernormalization101: LayerNorm,
    linear153: Linear,
    linear154: Linear,
    constant2142: burn::module::Param<Tensor<1>>,
    layernormalization102: LayerNorm,
    #[module(skip)]
    device: Device,
}
impl Submodule21 {
    #[allow(unused_variables)]
    pub fn new(device: &Device) -> Self {
        let layernormalization99 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d49 = Conv1dConfig::new(512, 1024, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let conv1d50 = Conv1dConfig::new(512, 512, 9)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(512)
            .with_bias(false)
            .init(device);
        let layernormalization100 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let conv1d51 = Conv1dConfig::new(512, 512, 1)
            .with_stride(1)
            .with_padding(PaddingConfig1d::Valid)
            .with_dilation(1)
            .with_groups(1)
            .with_bias(false)
            .init(device);
        let layernormalization101 = LayerNormConfig::new(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        let linear153 = LinearConfig::new(512, 2048).with_bias(false).init(device);
        let linear154 = LinearConfig::new(2048, 512).with_bias(false).init(device);
        let constant2142: 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(512)
            .with_epsilon(0.000009999999747378752f64)
            .with_bias(true)
            .init(device);
        Self {
            layernormalization99,
            conv1d49,
            conv1d50,
            layernormalization100,
            conv1d51,
            layernormalization101,
            linear153,
            linear154,
            constant2142,
            layernormalization102,
            device: device.clone(),
        }
    }
    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        add130_out1: Tensor<3>,
        unsqueeze119_out1: Tensor<3, Bool>,
        gather187_out1: Tensor<3>,
        concat27_out1: Tensor<3>,
        concat55_out1: Tensor<3>,
        concat66_out1: Tensor<3>,
        concat77_out1: Tensor<3>,
        concat88_out1: Tensor<3>,
        concat99_out1: Tensor<3>,
        concat110_out1: Tensor<3>,
        concat121_out1: Tensor<3>,
        concat132_out1: Tensor<3>,
        concat143_out1: Tensor<3>,
        concat154_out1: Tensor<3>,
        concat165_out1: Tensor<3>,
        concat176_out1: Tensor<3>,
        concat187_out1: Tensor<3>,
        concat198_out1: Tensor<3>,
        concat209_out1: Tensor<3>,
        concat220_out1: Tensor<3>,
        slice17_out1: Tensor<3>,
        slice25_out1: Tensor<3>,
        slice33_out1: Tensor<3>,
        slice41_out1: Tensor<3>,
        slice49_out1: Tensor<3>,
        slice57_out1: Tensor<3>,
        slice65_out1: Tensor<3>,
        slice73_out1: Tensor<3>,
        slice81_out1: Tensor<3>,
        slice89_out1: Tensor<3>,
        slice97_out1: Tensor<3>,
        slice105_out1: Tensor<3>,
        slice113_out1: Tensor<3>,
        slice121_out1: Tensor<3>,
        slice129_out1: Tensor<3>,
        slice137_out1: Tensor<3>,
        cache_last_channel_len: Tensor<1, Int>,
        gather39_out1: i64,
        clip1_out1: Tensor<1, Int>,
    ) -> (Tensor<3>, Tensor<1, Int>, Tensor<4>, Tensor<4>, Tensor<1, Int>) {
        let layernormalization99_out1 = {
            let dtype = add130_out1.clone().dtype();
            self.layernormalization99
                .forward(add130_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose206_out1 = layernormalization99_out1.permute([0, 2, 1]);
        let conv1d49_out1 = self.conv1d49.forward(transpose206_out1);
        let split_tensors = conv1d49_out1.split_with_sizes([512, 512].into(), 1);
        let [split17_out1, split17_out2] = split_tensors.try_into().unwrap();
        let sigmoid66_out1 = burn::tensor::activation::sigmoid(split17_out2);
        let mul144_out1 = split17_out1.mul(sigmoid66_out1);
        let constant2129_out1 = 0f32;
        let where69_out1 = mul144_out1.mask_fill(unsqueeze119_out1, constant2129_out1);
        let concat229_out1 = burn::tensor::Tensor::cat(
            [gather187_out1, where69_out1].into(),
            2,
        );
        let slice145_out1 = concat229_out1.clone().slice(s![.., .., - 8..]);
        let conv1d50_out1 = self.conv1d50.forward(concat229_out1);
        let transpose208_out1 = conv1d50_out1.permute([0, 2, 1]);
        let layernormalization100_out1 = {
            let dtype = transpose208_out1.dtype();
            self.layernormalization100
                .forward(transpose208_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose209_out1 = layernormalization100_out1.permute([0, 2, 1]);
        let sigmoid67_out1 = burn::tensor::activation::sigmoid(
            transpose209_out1.clone(),
        );
        let mul145_out1 = transpose209_out1.mul(sigmoid67_out1);
        let conv1d51_out1 = self.conv1d51.forward(mul145_out1);
        let transpose210_out1 = conv1d51_out1.permute([0, 2, 1]);
        let add131_out1 = add130_out1.add(transpose210_out1);
        let layernormalization101_out1 = {
            let dtype = add131_out1.clone().dtype();
            self.layernormalization101
                .forward(add131_out1.clone().cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let linear153_out1 = self.linear153.forward(layernormalization101_out1);
        let sigmoid68_out1 = burn::tensor::activation::sigmoid(linear153_out1.clone());
        let mul146_out1 = linear153_out1.mul(sigmoid68_out1);
        let linear154_out1 = self.linear154.forward(mul146_out1);
        let constant2142_out1 = self.constant2142.val();
        let mul147_out1 = linear154_out1
            .mul((constant2142_out1).unsqueeze_dims(&[0isize, 1isize]));
        let add132_out1 = add131_out1.add(mul147_out1);
        let layernormalization102_out1 = {
            let dtype = add132_out1.dtype();
            self.layernormalization102
                .forward(add132_out1.cast(burn::tensor::DType::F32))
                .cast(dtype)
        };
        let transpose211_out1 = layernormalization102_out1.permute([0, 2, 1]);
        let unsqueeze344_out1: Tensor<4> = concat27_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze345_out1: Tensor<4> = concat55_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze346_out1: Tensor<4> = concat66_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze347_out1: Tensor<4> = concat77_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze348_out1: Tensor<4> = concat88_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze349_out1: Tensor<4> = concat99_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze350_out1: Tensor<4> = concat110_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze351_out1: Tensor<4> = concat121_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze352_out1: Tensor<4> = concat132_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze353_out1: Tensor<4> = concat143_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze354_out1: Tensor<4> = concat154_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze355_out1: Tensor<4> = concat165_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze356_out1: Tensor<4> = concat176_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze357_out1: Tensor<4> = concat187_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze358_out1: Tensor<4> = concat198_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze359_out1: Tensor<4> = concat209_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze360_out1: Tensor<4> = concat220_out1.unsqueeze_dims::<4>(&[0]);
        let concat230_out1 = burn::tensor::Tensor::cat(
            [
                unsqueeze344_out1,
                unsqueeze345_out1,
                unsqueeze346_out1,
                unsqueeze347_out1,
                unsqueeze348_out1,
                unsqueeze349_out1,
                unsqueeze350_out1,
                unsqueeze351_out1,
                unsqueeze352_out1,
                unsqueeze353_out1,
                unsqueeze354_out1,
                unsqueeze355_out1,
                unsqueeze356_out1,
                unsqueeze357_out1,
                unsqueeze358_out1,
                unsqueeze359_out1,
                unsqueeze360_out1,
            ]
                .into(),
            0,
        );
        let unsqueeze361_out1: Tensor<4> = slice17_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze362_out1: Tensor<4> = slice25_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze363_out1: Tensor<4> = slice33_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze364_out1: Tensor<4> = slice41_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze365_out1: Tensor<4> = slice49_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze366_out1: Tensor<4> = slice57_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze367_out1: Tensor<4> = slice65_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze368_out1: Tensor<4> = slice73_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze369_out1: Tensor<4> = slice81_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze370_out1: Tensor<4> = slice89_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze371_out1: Tensor<4> = slice97_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze372_out1: Tensor<4> = slice105_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze373_out1: Tensor<4> = slice113_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze374_out1: Tensor<4> = slice121_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze375_out1: Tensor<4> = slice129_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze376_out1: Tensor<4> = slice137_out1.unsqueeze_dims::<4>(&[0]);
        let unsqueeze377_out1: Tensor<4> = slice145_out1.unsqueeze_dims::<4>(&[0]);
        let concat231_out1 = burn::tensor::Tensor::cat(
            [
                unsqueeze361_out1,
                unsqueeze362_out1,
                unsqueeze363_out1,
                unsqueeze364_out1,
                unsqueeze365_out1,
                unsqueeze366_out1,
                unsqueeze367_out1,
                unsqueeze368_out1,
                unsqueeze369_out1,
                unsqueeze370_out1,
                unsqueeze371_out1,
                unsqueeze372_out1,
                unsqueeze373_out1,
                unsqueeze374_out1,
                unsqueeze375_out1,
                unsqueeze376_out1,
                unsqueeze377_out1,
            ]
                .into(),
            0,
        );
        let add133_out1 = cache_last_channel_len.add_scalar(gather39_out1);
        let clip2_out1 = add133_out1.clamp_max(70f64);
        let slice146_out1 = concat230_out1.slice(s![.., .., - 70.., ..]);
        let slice147_out1 = transpose211_out1.slice(s![.., .., 0..2]);
        let clip3_out1 = clip1_out1.clamp_max(2f64);
        (slice147_out1, clip3_out1, slice146_out1, concat231_out1, clip2_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,
    #[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);
        Self {
            submodule1,
            submodule2,
            submodule3,
            submodule4,
            submodule5,
            submodule6,
            submodule7,
            submodule8,
            submodule9,
            submodule10,
            submodule11,
            submodule12,
            submodule13,
            submodule14,
            submodule15,
            submodule16,
            submodule17,
            submodule18,
            submodule19,
            submodule20,
            submodule21,
            device: device.clone(),
        }
    }

    #[allow(clippy::let_and_return, clippy::approx_constant)]
    pub fn forward(
        &self,
        audio_signal: Tensor<3>,
        length: Tensor<1, Int>,
        cache_last_channel: Tensor<4>,
        cache_last_time: Tensor<4>,
        cache_last_channel_len: Tensor<1, Int>,
    ) -> (Tensor<3>, Tensor<1, Int>, Tensor<4>, Tensor<4>, Tensor<1, Int>) {
        let (mul17_out1, add3_out1) = self.submodule1.forward(audio_signal, length);
        let (mul30_out1, add6_out1) = self.submodule2.forward(mul17_out1, add3_out1);
        let (mul43_out1, cast20_out1) = self.submodule3.forward(mul30_out1, add6_out1);
        let (
            and5_out1,
            and3_out1,
            slice4_out1,
            slice5_out1,
            gather39_out1,
            clip1_out1,
        ) = self
            .submodule4
            .forward(mul43_out1, cast20_out1, cache_last_channel_len.clone());
        let (add18_out1, slice8_out1, gather42_out1, unsqueeze117_out1, concat27_out1) = self
            .submodule5
            .forward(
                and5_out1,
                and3_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice4_out1,
                slice5_out1.clone(),
            );
        let (
            add25_out1,
            unsqueeze119_out1,
            gather52_out1,
            concat55_out1,
            slice17_out1,
        ) = self
            .submodule6
            .forward(
                add18_out1,
                slice8_out1,
                gather42_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add32_out1, gather61_out1, concat66_out1, slice25_out1) = self
            .submodule7
            .forward(
                add25_out1,
                unsqueeze119_out1.clone(),
                gather52_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add39_out1, gather70_out1, concat77_out1, slice33_out1) = self
            .submodule8
            .forward(
                add32_out1,
                unsqueeze119_out1.clone(),
                gather61_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add46_out1, gather79_out1, concat88_out1, slice41_out1) = self
            .submodule9
            .forward(
                add39_out1,
                unsqueeze119_out1.clone(),
                gather70_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add53_out1, gather88_out1, concat99_out1, slice49_out1) = self
            .submodule10
            .forward(
                add46_out1,
                unsqueeze119_out1.clone(),
                gather79_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add60_out1, gather97_out1, concat110_out1, slice57_out1) = self
            .submodule11
            .forward(
                add53_out1,
                unsqueeze119_out1.clone(),
                gather88_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add67_out1, gather106_out1, concat121_out1, slice65_out1) = self
            .submodule12
            .forward(
                add60_out1,
                unsqueeze119_out1.clone(),
                gather97_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add74_out1, gather115_out1, concat132_out1, slice73_out1) = self
            .submodule13
            .forward(
                add67_out1,
                unsqueeze119_out1.clone(),
                gather106_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add81_out1, gather124_out1, concat143_out1, slice81_out1) = self
            .submodule14
            .forward(
                add74_out1,
                unsqueeze119_out1.clone(),
                gather115_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add88_out1, gather133_out1, concat154_out1, slice89_out1) = self
            .submodule15
            .forward(
                add81_out1,
                unsqueeze119_out1.clone(),
                gather124_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add95_out1, gather142_out1, concat165_out1, slice97_out1) = self
            .submodule16
            .forward(
                add88_out1,
                unsqueeze119_out1.clone(),
                gather133_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add102_out1, gather151_out1, concat176_out1, slice105_out1) = self
            .submodule17
            .forward(
                add95_out1,
                unsqueeze119_out1.clone(),
                gather142_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add109_out1, gather160_out1, concat187_out1, slice113_out1) = self
            .submodule18
            .forward(
                add102_out1,
                unsqueeze119_out1.clone(),
                gather151_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (add116_out1, gather169_out1, concat198_out1, slice121_out1) = self
            .submodule19
            .forward(
                add109_out1,
                unsqueeze119_out1.clone(),
                gather160_out1,
                cache_last_channel.clone(),
                cache_last_time.clone(),
                slice5_out1.clone(),
                unsqueeze117_out1.clone(),
            );
        let (
            add130_out1,
            gather187_out1,
            concat209_out1,
            concat220_out1,
            slice129_out1,
            slice137_out1,
        ) = self
            .submodule20
            .forward(
                add116_out1,
                unsqueeze119_out1.clone(),
                gather169_out1,
                cache_last_channel,
                cache_last_time,
                slice5_out1,
                unsqueeze117_out1,
            );
        let (slice147_out1, clip3_out1, slice146_out1, concat231_out1, clip2_out1) = self
            .submodule21
            .forward(
                add130_out1,
                unsqueeze119_out1,
                gather187_out1,
                concat27_out1,
                concat55_out1,
                concat66_out1,
                concat77_out1,
                concat88_out1,
                concat99_out1,
                concat110_out1,
                concat121_out1,
                concat132_out1,
                concat143_out1,
                concat154_out1,
                concat165_out1,
                concat176_out1,
                concat187_out1,
                concat198_out1,
                concat209_out1,
                concat220_out1,
                slice17_out1,
                slice25_out1,
                slice33_out1,
                slice41_out1,
                slice49_out1,
                slice57_out1,
                slice65_out1,
                slice73_out1,
                slice81_out1,
                slice89_out1,
                slice97_out1,
                slice105_out1,
                slice113_out1,
                slice121_out1,
                slice129_out1,
                slice137_out1,
                cache_last_channel_len,
                gather39_out1,
                clip1_out1,
            );
        (slice147_out1, clip3_out1, slice146_out1, concat231_out1, clip2_out1)
    }
}