xfeatFcn.m

function [matched_points1, matched_points2, state] = xfeat(input1, input2, params, varargin)
%XFEAT Function implementing an imported ONNX network.
%
% THIS FILE WAS AUTO-GENERATED BY importONNXFunction.
% ONNX Operator Set Version: 15
%
% Variable names in this function are taken from the original ONNX file.
%
% [MATCHED_POINTS1, MATCHED_POINTS2] = xfeat(INPUT1, INPUT2, PARAMS)
%			- Evaluates the imported ONNX network XFEAT with input(s)
%			INPUT1, INPUT2 and the imported network parameters in PARAMS. Returns
%			network output(s) in MATCHED_POINTS1, MATCHED_POINTS2.
%
% [MATCHED_POINTS1, MATCHED_POINTS2, STATE] = xfeat(INPUT1, INPUT2, PARAMS)
%			- Additionally returns state variables in STATE. When training,
%			use this form and set TRAINING to true.
%
% [__] = xfeat(INPUT1, INPUT2, PARAMS, 'NAME1', VAL1, 'NAME2', VAL2, ...)
%			- Specifies additional name-value pairs described below:
%
% 'Training'
% 			Boolean indicating whether the network is being evaluated for
%			prediction or training. If TRAINING is true, state variables
%			will be updated.
%
% 'InputDataPermutation'
%			'auto' - Automatically attempt to determine the permutation
%			 between the dimensions of the input data and the dimensions of
%			the ONNX model input. For example, the permutation from HWCN
%			(MATLAB standard) to NCHW (ONNX standard) uses the vector
%			[4 3 1 2]. See the documentation for IMPORTONNXFUNCTION for
%			more information about automatic permutation.
%
%			'none' - Input(s) are passed in the ONNX model format. See 'Inputs'.
%
%			numeric vector - The permutation vector describing the
%			transformation between input data dimensions and the expected
%			ONNX input dimensions.%
%			cell array - If the network has multiple inputs, each cell
%			contains 'auto', 'none', or a numeric vector.
%
% 'OutputDataPermutation'
%			'auto' - Automatically attempt to determine the permutation
%			between the dimensions of the output and a conventional MATLAB
%			dimension ordering. For example, the permutation from NC (ONNX
%			standard) to CN (MATLAB standard) uses the vector [2 1]. See
%			the documentation for IMPORTONNXFUNCTION for more information
%			about automatic permutation.
%
%			'none' - Return output(s) as given by the ONNX model. See 'Outputs'.
%
%			numeric vector - The permutation vector describing the
%			transformation between the ONNX output dimensions and the
%			desired output dimensions.%
%			cell array - If the network has multiple outputs, each cell
%			contains 'auto', 'none' or a numeric vector.
%
% Inputs:
% -------
% INPUT1, INPUT2
%			- Input(s) to the ONNX network.
%			  The input size(s) expected by the ONNX file are:
%				  INPUT1:		[1, 3, height, width]				Type: FLOAT
%				  INPUT2:		[1, 3, height, width]				Type: FLOAT
%			  By default, the function will try to permute the input(s)
%			  into this dimension ordering. If the default is incorrect,
%			  use the 'InputDataPermutation' argument to control the
%			  permutation.
%
%
% PARAMS	- Network parameters returned by 'importONNXFunction'.
%
%
% Outputs:
% --------
% MATCHED_POINTS1, MATCHED_POINTS2
%			- Output(s) of the ONNX network.
%			  Without permutation, the size(s) of the outputs are:
%				  MATCHED_POINTS1:		[num_matches, 2]				Type: FLOAT
%				  MATCHED_POINTS2:		[num_matches, 2]				Type: FLOAT
%			  By default, the function will try to permute the output(s)
%			  from this dimension ordering into a conventional MATLAB
%			  ordering. If the default is incorrect, use the
%			  'OutputDataPermutation' argument to control the permutation.
%
% STATE		- (Optional) State variables. When TRAINING is true, these will
% 			  have been updated from the original values in PARAMS.State.
%
%
%  See also importONNXFunction

% Preprocess the input data and arguments:
[input1, input2, Training, outputDataPerms, anyDlarrayInputs] = preprocessInput(input1, input2, params, varargin{:});
% Put all variables into a single struct to implement dynamic scoping:
[Vars, NumDims] = packageVariables(params, {'input1', 'input2'}, {input1, input2}, [4 4]);
% Call the top-level graph function:
[matched_points1, matched_points2, matched_points1NumDims, matched_points2NumDims, state] = main_graphGraph1000(input1, input2, NumDims.input1, NumDims.input2, Vars, NumDims, Training, params.State);
% Postprocess the output data
[matched_points1, matched_points2] = postprocessOutput(matched_points1, matched_points2, outputDataPerms, anyDlarrayInputs, Training, varargin{:});
end

function [matched_points1, matched_points2, matched_points1NumDims1320, matched_points2NumDims1321, state] = main_graphGraph1000(input1, input2, input1NumDims1318, input2NumDims1319, Vars, NumDims, Training, state)
% Function implementing the graph 'main_graphGraph1000'
% Update Vars and NumDims from the graph's formal input parameters. Note that state variables are already in Vars.
Vars.input1 = input1;
NumDims.input1 = input1NumDims1318;
Vars.input2 = input2;
NumDims.input2 = input2NumDims1319;

% Execute the operators:
% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_output_0] = prepareResize11Args(dlarray([]), Vars.x_Constant_output_0, dlarray([]), "half_pixel", "linear", "floor", NumDims.input1);
if isempty(DLTScales)
    Vars.x_Resize_output_0 = dlresize(Vars.input1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_output_0 = dlresize(Vars.input1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_1_output_0] = prepareResize11Args(dlarray([]), Vars.x_Constant_1_output_0, dlarray([]), "half_pixel", "linear", "floor", NumDims.input1);
if isempty(DLTScales)
    Vars.x_Resize_1_output_0 = dlresize(Vars.input1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_1_output_0 = dlresize(Vars.input1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Shape:
[Vars.x_Shape_output_0, NumDims.x_Shape_output_0] = onnxShape(Vars.x_Resize_output_0, NumDims.x_Resize_output_0, 0, NumDims.x_Resize_output_0+1);

% Gather:
[Vars.x_Gather_output_0, NumDims.x_Gather_output_0] = onnxGather(Vars.x_Shape_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_1_output_0, NumDims.x_Gather_1_output_0] = onnxGather(Vars.x_Shape_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_output_0, NumDims.x_Constant_3_output_0);

% Div:
Vars.x_Div_output_0 = fix(Vars.x_Gather_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_output_0 = max(NumDims.x_Gather_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_output_0 = Vars.x_Div_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_output_0 = max(NumDims.x_Div_output_0, NumDims.x_Constant_4_output_0);

% Div:
Vars.x_Div_1_output_0 = fix(Vars.x_Gather_1_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_1_output_0 = max(NumDims.x_Gather_1_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_1_output_0 = Vars.x_Div_1_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_1_output_0 = max(NumDims.x_Div_1_output_0, NumDims.x_Constant_4_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_output_0);
Vars.x_Unsqueeze_output_0 = reshape(Vars.x_Mul_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_1_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_1_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_1_output_0);
Vars.x_Unsqueeze_1_output_0 = reshape(Vars.x_Mul_1_output_0, shape);

% Concat:
[Vars.x_Concat_1_output_0, NumDims.x_Concat_1_output_0] = onnxConcat(0, {Vars.x_v_1924, Vars.x_Unsqueeze_output_0, Vars.x_Unsqueeze_1_output_0}, [NumDims.x_v_1924, NumDims.x_Unsqueeze_output_0, NumDims.x_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_2_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_Concat_1_output_0, "half_pixel", "linear", "floor", NumDims.x_Resize_output_0);
if isempty(DLTScales)
    Vars.x_Resize_2_output_0 = dlresize(Vars.x_Resize_output_0, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_2_output_0 = dlresize(Vars.x_Resize_output_0, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% ReduceMean:
dims = prepareReduceArgs(Vars.ReduceMeanAxes1001, NumDims.x_Resize_2_output_0);
Vars.x_net_ReduceMean_output_0 = mean(Vars.x_Resize_2_output_0, dims);
NumDims.x_net_ReduceMean_output_0 = NumDims.x_Resize_2_output_0;

% InstanceNormalization:
if NumDims.x_net_ReduceMean_output_0 > 1
    Vars.x_net_norm_InstanceNormalization_output_ = instancenorm(Vars.x_net_ReduceMean_output_0, Vars.x_net_norm_Constant_1_output_0, Vars.x_net_norm_Constant_output_0, 'Epsilon', 0.000010, 'DataFormat', [repmat('S',[1 NumDims.x_net_ReduceMean_output_0-2]),'CB']);
end
NumDims.x_net_norm_InstanceNormalization_output_ = NumDims.x_net_ReduceMean_output_0;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_0_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1526, Vars.onnx__Conv_1527, Vars.ConvStride1002, Vars.ConvDilationFactor1003, Vars.ConvPadding1004, 1, NumDims.x_net_norm_InstanceNormalization_output_, NumDims.onnx__Conv_1526);
Vars.x_net_block1_block1_0_layer_layer_0_Co_1 = dlconv(Vars.x_net_norm_InstanceNormalization_output_, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_0_layer_layer_2_Re_1 = relu(Vars.x_net_block1_block1_0_layer_layer_0_Co_1);
NumDims.x_net_block1_block1_0_layer_layer_2_Re_1 = NumDims.x_net_block1_block1_0_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_1_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1529, Vars.onnx__Conv_1530, Vars.ConvStride1005, Vars.ConvDilationFactor1006, Vars.ConvPadding1007, 1, NumDims.x_net_block1_block1_0_layer_layer_2_Re_1, NumDims.onnx__Conv_1529);
Vars.x_net_block1_block1_1_layer_layer_0_Co_1 = dlconv(Vars.x_net_block1_block1_0_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_1_layer_layer_2_Re_1 = relu(Vars.x_net_block1_block1_1_layer_layer_0_Co_1);
NumDims.x_net_block1_block1_1_layer_layer_2_Re_1 = NumDims.x_net_block1_block1_1_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_2_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1532, Vars.onnx__Conv_1533, Vars.ConvStride1008, Vars.ConvDilationFactor1009, Vars.ConvPadding1010, 1, NumDims.x_net_block1_block1_1_layer_layer_2_Re_1, NumDims.onnx__Conv_1532);
Vars.x_net_block1_block1_2_layer_layer_0_Co_1 = dlconv(Vars.x_net_block1_block1_1_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_2_layer_layer_2_Re_1 = relu(Vars.x_net_block1_block1_2_layer_layer_0_Co_1);
NumDims.x_net_block1_block1_2_layer_layer_2_Re_1 = NumDims.x_net_block1_block1_2_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_3_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1535, Vars.onnx__Conv_1536, Vars.ConvStride1011, Vars.ConvDilationFactor1012, Vars.ConvPadding1013, 1, NumDims.x_net_block1_block1_2_layer_layer_2_Re_1, NumDims.onnx__Conv_1535);
Vars.x_net_block1_block1_3_layer_layer_0_Co_1 = dlconv(Vars.x_net_block1_block1_2_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_3_layer_layer_2_Re_1 = relu(Vars.x_net_block1_block1_3_layer_layer_0_Co_1);
NumDims.x_net_block1_block1_3_layer_layer_2_Re_1 = NumDims.x_net_block1_block1_3_layer_layer_0_Co_1;

% AveragePool:
[poolSize, stride, padding, paddingValue, dataFormat, NumDims.x_net_skip1_skip1_0_AveragePool_output_0] = prepareAveragePoolArgs(Vars.AveragePoolPoolSize1014, Vars.AveragePoolStride1015, Vars.AveragePoolPadding1016, 1, NumDims.x_net_norm_InstanceNormalization_output_);
Vars.x_net_skip1_skip1_0_AveragePool_output_0 = avgpool(Vars.x_net_norm_InstanceNormalization_output_, poolSize, 'Stride', stride, 'Padding', padding, 'PaddingValue', paddingValue, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_skip1_skip1_1_Conv_output_0] = prepareConvArgs(Vars.net_skip1_1_weight, Vars.net_skip1_1_bias, Vars.ConvStride1017, Vars.ConvDilationFactor1018, Vars.ConvPadding1019, 1, NumDims.x_net_skip1_skip1_0_AveragePool_output_0, NumDims.net_skip1_1_weight);
Vars.x_net_skip1_skip1_1_Conv_output_0 = dlconv(Vars.x_net_skip1_skip1_0_AveragePool_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Add:
Vars.x_net_Add_output_0 = Vars.x_net_block1_block1_3_layer_layer_2_Re_1 + Vars.x_net_skip1_skip1_1_Conv_output_0;
NumDims.x_net_Add_output_0 = max(NumDims.x_net_block1_block1_3_layer_layer_2_Re_1, NumDims.x_net_skip1_skip1_1_Conv_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_0_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1538, Vars.onnx__Conv_1539, Vars.ConvStride1020, Vars.ConvDilationFactor1021, Vars.ConvPadding1022, 1, NumDims.x_net_Add_output_0, NumDims.onnx__Conv_1538);
Vars.x_net_block2_block2_0_layer_layer_0_Co_1 = dlconv(Vars.x_net_Add_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_0_layer_layer_2_Re_1 = relu(Vars.x_net_block2_block2_0_layer_layer_0_Co_1);
NumDims.x_net_block2_block2_0_layer_layer_2_Re_1 = NumDims.x_net_block2_block2_0_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_1_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1541, Vars.onnx__Conv_1542, Vars.ConvStride1023, Vars.ConvDilationFactor1024, Vars.ConvPadding1025, 1, NumDims.x_net_block2_block2_0_layer_layer_2_Re_1, NumDims.onnx__Conv_1541);
Vars.x_net_block2_block2_1_layer_layer_0_Co_1 = dlconv(Vars.x_net_block2_block2_0_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_1_layer_layer_2_Re_1 = relu(Vars.x_net_block2_block2_1_layer_layer_0_Co_1);
NumDims.x_net_block2_block2_1_layer_layer_2_Re_1 = NumDims.x_net_block2_block2_1_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_0_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1544, Vars.onnx__Conv_1545, Vars.ConvStride1026, Vars.ConvDilationFactor1027, Vars.ConvPadding1028, 1, NumDims.x_net_block2_block2_1_layer_layer_2_Re_1, NumDims.onnx__Conv_1544);
Vars.x_net_block3_block3_0_layer_layer_0_Co_1 = dlconv(Vars.x_net_block2_block2_1_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_0_layer_layer_2_Re_1 = relu(Vars.x_net_block3_block3_0_layer_layer_0_Co_1);
NumDims.x_net_block3_block3_0_layer_layer_2_Re_1 = NumDims.x_net_block3_block3_0_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_1_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1547, Vars.onnx__Conv_1548, Vars.ConvStride1029, Vars.ConvDilationFactor1030, Vars.ConvPadding1031, 1, NumDims.x_net_block3_block3_0_layer_layer_2_Re_1, NumDims.onnx__Conv_1547);
Vars.x_net_block3_block3_1_layer_layer_0_Co_1 = dlconv(Vars.x_net_block3_block3_0_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_1_layer_layer_2_Re_1 = relu(Vars.x_net_block3_block3_1_layer_layer_0_Co_1);
NumDims.x_net_block3_block3_1_layer_layer_2_Re_1 = NumDims.x_net_block3_block3_1_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_2_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1550, Vars.onnx__Conv_1551, Vars.ConvStride1032, Vars.ConvDilationFactor1033, Vars.ConvPadding1034, 1, NumDims.x_net_block3_block3_1_layer_layer_2_Re_1, NumDims.onnx__Conv_1550);
Vars.x_net_block3_block3_2_layer_layer_0_Co_1 = dlconv(Vars.x_net_block3_block3_1_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_2_layer_layer_2_Re_1 = relu(Vars.x_net_block3_block3_2_layer_layer_0_Co_1);
NumDims.x_net_block3_block3_2_layer_layer_2_Re_1 = NumDims.x_net_block3_block3_2_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_0_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1553, Vars.onnx__Conv_1554, Vars.ConvStride1035, Vars.ConvDilationFactor1036, Vars.ConvPadding1037, 1, NumDims.x_net_block3_block3_2_layer_layer_2_Re_1, NumDims.onnx__Conv_1553);
Vars.x_net_block4_block4_0_layer_layer_0_Co_1 = dlconv(Vars.x_net_block3_block3_2_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_0_layer_layer_2_Re_1 = relu(Vars.x_net_block4_block4_0_layer_layer_0_Co_1);
NumDims.x_net_block4_block4_0_layer_layer_2_Re_1 = NumDims.x_net_block4_block4_0_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_1_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1556, Vars.onnx__Conv_1557, Vars.ConvStride1038, Vars.ConvDilationFactor1039, Vars.ConvPadding1040, 1, NumDims.x_net_block4_block4_0_layer_layer_2_Re_1, NumDims.onnx__Conv_1556);
Vars.x_net_block4_block4_1_layer_layer_0_Co_1 = dlconv(Vars.x_net_block4_block4_0_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_1_layer_layer_2_Re_1 = relu(Vars.x_net_block4_block4_1_layer_layer_0_Co_1);
NumDims.x_net_block4_block4_1_layer_layer_2_Re_1 = NumDims.x_net_block4_block4_1_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_2_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1559, Vars.onnx__Conv_1560, Vars.ConvStride1041, Vars.ConvDilationFactor1042, Vars.ConvPadding1043, 1, NumDims.x_net_block4_block4_1_layer_layer_2_Re_1, NumDims.onnx__Conv_1559);
Vars.x_net_block4_block4_2_layer_layer_0_Co_1 = dlconv(Vars.x_net_block4_block4_1_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_2_layer_layer_2_Re_1 = relu(Vars.x_net_block4_block4_2_layer_layer_0_Co_1);
NumDims.x_net_block4_block4_2_layer_layer_2_Re_1 = NumDims.x_net_block4_block4_2_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_0_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1562, Vars.onnx__Conv_1563, Vars.ConvStride1044, Vars.ConvDilationFactor1045, Vars.ConvPadding1046, 1, NumDims.x_net_block4_block4_2_layer_layer_2_Re_1, NumDims.onnx__Conv_1562);
Vars.x_net_block5_block5_0_layer_layer_0_Co_1 = dlconv(Vars.x_net_block4_block4_2_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_0_layer_layer_2_Re_1 = relu(Vars.x_net_block5_block5_0_layer_layer_0_Co_1);
NumDims.x_net_block5_block5_0_layer_layer_2_Re_1 = NumDims.x_net_block5_block5_0_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_1_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1565, Vars.onnx__Conv_1566, Vars.ConvStride1047, Vars.ConvDilationFactor1048, Vars.ConvPadding1049, 1, NumDims.x_net_block5_block5_0_layer_layer_2_Re_1, NumDims.onnx__Conv_1565);
Vars.x_net_block5_block5_1_layer_layer_0_Co_1 = dlconv(Vars.x_net_block5_block5_0_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_1_layer_layer_2_Re_1 = relu(Vars.x_net_block5_block5_1_layer_layer_0_Co_1);
NumDims.x_net_block5_block5_1_layer_layer_2_Re_1 = NumDims.x_net_block5_block5_1_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_2_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1568, Vars.onnx__Conv_1569, Vars.ConvStride1050, Vars.ConvDilationFactor1051, Vars.ConvPadding1052, 1, NumDims.x_net_block5_block5_1_layer_layer_2_Re_1, NumDims.onnx__Conv_1568);
Vars.x_net_block5_block5_2_layer_layer_0_Co_1 = dlconv(Vars.x_net_block5_block5_1_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_2_layer_layer_2_Re_1 = relu(Vars.x_net_block5_block5_2_layer_layer_0_Co_1);
NumDims.x_net_block5_block5_2_layer_layer_2_Re_1 = NumDims.x_net_block5_block5_2_layer_layer_0_Co_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_3_layer_layer_0_Co_1] = prepareConvArgs(Vars.onnx__Conv_1571, Vars.onnx__Conv_1572, Vars.ConvStride1053, Vars.ConvDilationFactor1054, Vars.ConvPadding1055, 1, NumDims.x_net_block5_block5_2_layer_layer_2_Re_1, NumDims.onnx__Conv_1571);
Vars.x_net_block5_block5_3_layer_layer_0_Co_1 = dlconv(Vars.x_net_block5_block5_2_layer_layer_2_Re_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_3_layer_layer_2_Re_1 = relu(Vars.x_net_block5_block5_3_layer_layer_0_Co_1);
NumDims.x_net_block5_block5_3_layer_layer_2_Re_1 = NumDims.x_net_block5_block5_3_layer_layer_0_Co_1;

% Shape:
[Vars.x_net_Shape_output_0, NumDims.x_net_Shape_output_0] = onnxShape(Vars.x_net_block3_block3_2_layer_layer_2_Re_1, NumDims.x_net_block3_block3_2_layer_layer_2_Re_1, 0, NumDims.x_net_block3_block3_2_layer_layer_2_Re_1+1);

% Gather:
[Vars.x_net_Gather_output_0, NumDims.x_net_Gather_output_0] = onnxGather(Vars.x_net_Shape_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_net_Shape_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_net_Gather_1_output_0, NumDims.x_net_Gather_1_output_0] = onnxGather(Vars.x_net_Shape_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_net_Shape_output_0, NumDims.x_Constant_3_output_0);

% Unsqueeze:
[shape, NumDims.x_net_Unsqueeze_output_0] = prepareUnsqueezeArgs(Vars.x_net_Gather_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_Gather_output_0);
Vars.x_net_Unsqueeze_output_0 = reshape(Vars.x_net_Gather_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_net_Unsqueeze_1_output_0] = prepareUnsqueezeArgs(Vars.x_net_Gather_1_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_Gather_1_output_0);
Vars.x_net_Unsqueeze_1_output_0 = reshape(Vars.x_net_Gather_1_output_0, shape);

% Shape:
[Vars.x_net_Shape_2_output_0, NumDims.x_net_Shape_2_output_0] = onnxShape(Vars.x_net_block4_block4_2_layer_layer_2_Re_1, NumDims.x_net_block4_block4_2_layer_layer_2_Re_1, 0, NumDims.x_net_block4_block4_2_layer_layer_2_Re_1+1);

% Slice:
[Indices, NumDims.x_net_Slice_output_0] = prepareSliceArgs(Vars.x_net_Shape_2_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_Shape_2_output_0);
Vars.x_net_Slice_output_0 = subsref(Vars.x_net_Shape_2_output_0, Indices);

% Concat:
[Vars.x_net_Concat_1_output_0, NumDims.x_net_Concat_1_output_0] = onnxConcat(0, {Vars.x_net_Slice_output_0, Vars.x_net_Unsqueeze_output_0, Vars.x_net_Unsqueeze_1_output_0}, [NumDims.x_net_Slice_output_0, NumDims.x_net_Unsqueeze_output_0, NumDims.x_net_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_Resize_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_Concat_1_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block4_block4_2_layer_layer_2_Re_1);
if isempty(DLTScales)
    Vars.x_net_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_Re_1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_Re_1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Shape:
[Vars.x_net_Shape_5_output_0, NumDims.x_net_Shape_5_output_0] = onnxShape(Vars.x_net_block5_block5_3_layer_layer_2_Re_1, NumDims.x_net_block5_block5_3_layer_layer_2_Re_1, 0, NumDims.x_net_block5_block5_3_layer_layer_2_Re_1+1);

% Slice:
[Indices, NumDims.x_net_Slice_1_output_0] = prepareSliceArgs(Vars.x_net_Shape_5_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_Shape_5_output_0);
Vars.x_net_Slice_1_output_0 = subsref(Vars.x_net_Shape_5_output_0, Indices);

% Concat:
[Vars.x_net_Concat_3_output_0, NumDims.x_net_Concat_3_output_0] = onnxConcat(0, {Vars.x_net_Slice_1_output_0, Vars.x_net_Unsqueeze_output_0, Vars.x_net_Unsqueeze_1_output_0}, [NumDims.x_net_Slice_1_output_0, NumDims.x_net_Unsqueeze_output_0, NumDims.x_net_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_Resize_1_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_Concat_3_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block5_block5_3_layer_layer_2_Re_1);
if isempty(DLTScales)
    Vars.x_net_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_Re_1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_Re_1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Add:
Vars.x_net_Add_1_output_0 = Vars.x_net_block3_block3_2_layer_layer_2_Re_1 + Vars.x_net_Resize_output_0;
NumDims.x_net_Add_1_output_0 = max(NumDims.x_net_block3_block3_2_layer_layer_2_Re_1, NumDims.x_net_Resize_output_0);

% Add:
Vars.x_net_Add_2_output_0 = Vars.x_net_Add_1_output_0 + Vars.x_net_Resize_1_output_0;
NumDims.x_net_Add_2_output_0 = max(NumDims.x_net_Add_1_output_0, NumDims.x_net_Resize_1_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_0_lay_1] = prepareConvArgs(Vars.onnx__Conv_1574, Vars.onnx__Conv_1575, Vars.ConvStride1056, Vars.ConvDilationFactor1057, Vars.ConvPadding1058, 1, NumDims.x_net_Add_2_output_0, NumDims.onnx__Conv_1574);
Vars.x_net_block_fusion_block_fusion_0_lay_1 = dlconv(Vars.x_net_Add_2_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_0_lay_9 = relu(Vars.x_net_block_fusion_block_fusion_0_lay_1);
NumDims.x_net_block_fusion_block_fusion_0_lay_9 = NumDims.x_net_block_fusion_block_fusion_0_lay_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_1_lay_1] = prepareConvArgs(Vars.onnx__Conv_1577, Vars.onnx__Conv_1578, Vars.ConvStride1059, Vars.ConvDilationFactor1060, Vars.ConvPadding1061, 1, NumDims.x_net_block_fusion_block_fusion_0_lay_9, NumDims.onnx__Conv_1577);
Vars.x_net_block_fusion_block_fusion_1_lay_1 = dlconv(Vars.x_net_block_fusion_block_fusion_0_lay_9, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_1_lay_9 = relu(Vars.x_net_block_fusion_block_fusion_1_lay_1);
NumDims.x_net_block_fusion_block_fusion_1_lay_9 = NumDims.x_net_block_fusion_block_fusion_1_lay_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_2_Conv_o] = prepareConvArgs(Vars.net_block_fusion_2_weight, Vars.net_block_fusion_2_bias, Vars.ConvStride1062, Vars.ConvDilationFactor1063, Vars.ConvPadding1064, 1, NumDims.x_net_block_fusion_block_fusion_1_lay_9, NumDims.net_block_fusion_2_weight);
Vars.x_net_block_fusion_block_fusion_2_Conv_o = dlconv(Vars.x_net_block_fusion_block_fusion_1_lay_9, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_0_lay_1] = prepareConvArgs(Vars.onnx__Conv_1580, Vars.onnx__Conv_1581, Vars.ConvStride1065, Vars.ConvDilationFactor1066, Vars.ConvPadding1067, 1, NumDims.x_net_block_fusion_block_fusion_2_Conv_o, NumDims.onnx__Conv_1580);
Vars.x_net_heatmap_head_heatmap_head_0_lay_1 = dlconv(Vars.x_net_block_fusion_block_fusion_2_Conv_o, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_0_lay_9 = relu(Vars.x_net_heatmap_head_heatmap_head_0_lay_1);
NumDims.x_net_heatmap_head_heatmap_head_0_lay_9 = NumDims.x_net_heatmap_head_heatmap_head_0_lay_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_1_lay_1] = prepareConvArgs(Vars.onnx__Conv_1583, Vars.onnx__Conv_1584, Vars.ConvStride1068, Vars.ConvDilationFactor1069, Vars.ConvPadding1070, 1, NumDims.x_net_heatmap_head_heatmap_head_0_lay_9, NumDims.onnx__Conv_1583);
Vars.x_net_heatmap_head_heatmap_head_1_lay_1 = dlconv(Vars.x_net_heatmap_head_heatmap_head_0_lay_9, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_1_lay_9 = relu(Vars.x_net_heatmap_head_heatmap_head_1_lay_1);
NumDims.x_net_heatmap_head_heatmap_head_1_lay_9 = NumDims.x_net_heatmap_head_heatmap_head_1_lay_1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_2_Conv_o] = prepareConvArgs(Vars.net_heatmap_head_2_weight, Vars.net_heatmap_head_2_bias, Vars.ConvStride1071, Vars.ConvDilationFactor1072, Vars.ConvPadding1073, 1, NumDims.x_net_heatmap_head_heatmap_head_1_lay_9, NumDims.net_heatmap_head_2_weight);
Vars.x_net_heatmap_head_heatmap_head_2_Conv_o = dlconv(Vars.x_net_heatmap_head_heatmap_head_1_lay_9, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Sigmoid:
Vars.x_net_heatmap_head_heatmap_head_3_Sigm_1 = sigmoid(Vars.x_net_heatmap_head_heatmap_head_2_Conv_o);
NumDims.x_net_heatmap_head_heatmap_head_3_Sigm_1 = NumDims.x_net_heatmap_head_heatmap_head_2_Conv_o;

% Shape:
[Vars.x_Shape_3_output_0, NumDims.x_Shape_3_output_0] = onnxShape(Vars.x_net_block_fusion_block_fusion_2_Conv_o, NumDims.x_net_block_fusion_block_fusion_2_Conv_o, 0, NumDims.x_net_block_fusion_block_fusion_2_Conv_o+1);

% Gather:
[Vars.x_Gather_2_output_0, NumDims.x_Gather_2_output_0] = onnxGather(Vars.x_Shape_3_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Shape_3_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_4_output_0, NumDims.x_Gather_4_output_0] = onnxGather(Vars.x_Shape_3_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_3_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_5_output_0, NumDims.x_Gather_5_output_0] = onnxGather(Vars.x_Shape_3_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_3_output_0, NumDims.x_Constant_3_output_0);

% Range:
Vars.x_Range_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_4_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_output_0 = 1;

% Range:
Vars.x_Range_1_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_5_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_1_output_0 = 1;

% Shape:
[Vars.x_Shape_7_output_0, NumDims.x_Shape_7_output_0] = onnxShape(Vars.x_Range_output_0, NumDims.x_Range_output_0, 0, NumDims.x_Range_output_0+1);

% Shape:
[Vars.x_Shape_8_output_0, NumDims.x_Shape_8_output_0] = onnxShape(Vars.x_Range_1_output_0, NumDims.x_Range_1_output_0, 0, NumDims.x_Range_1_output_0+1);

% Concat:
[Vars.x_Concat_2_output_0, NumDims.x_Concat_2_output_0] = onnxConcat(0, {Vars.x_Shape_7_output_0, Vars.x_Shape_8_output_0}, [NumDims.x_Shape_7_output_0, NumDims.x_Shape_8_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_2_output_0] = prepareReshapeArgs(Vars.x_Range_output_0, Vars.x_v_1932, NumDims.x_Range_output_0, 0);
Vars.x_Reshape_2_output_0 = reshape(Vars.x_Range_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_output_0] = prepareExpandArgs(Vars.x_Concat_2_output_0);
Vars.x_Expand_output_0 = Vars.x_Reshape_2_output_0 + zeros(shape);

% Reshape:
[shape, NumDims.x_Reshape_3_output_0] = prepareReshapeArgs(Vars.x_Range_1_output_0, Vars.x_v_1934, NumDims.x_Range_1_output_0, 0);
Vars.x_Reshape_3_output_0 = reshape(Vars.x_Range_1_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_1_output_0] = prepareExpandArgs(Vars.x_Concat_2_output_0);
Vars.x_Expand_1_output_0 = Vars.x_Reshape_3_output_0 + zeros(shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_2_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_1_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_1_output_0);
Vars.x_Unsqueeze_2_output_0 = reshape(Vars.x_Expand_1_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_3_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_output_0);
Vars.x_Unsqueeze_3_output_0 = reshape(Vars.x_Expand_output_0, shape);

% Concat:
[Vars.x_Concat_5_output_0, NumDims.x_Concat_5_output_0] = onnxConcat(-1, {Vars.x_Unsqueeze_2_output_0, Vars.x_Unsqueeze_3_output_0}, [NumDims.x_Unsqueeze_2_output_0, NumDims.x_Unsqueeze_3_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_4_output_0] = prepareReshapeArgs(Vars.x_Concat_5_output_0, Vars.x_Constant_26_output_0, NumDims.x_Concat_5_output_0, 0);
Vars.x_Reshape_4_output_0 = reshape(Vars.x_Concat_5_output_0, shape{:});

% Mul:
Vars.x_Mul_2_output_0 = Vars.x_Reshape_4_output_0 .* Vars.x_Constant_27_output_0;
NumDims.x_Mul_2_output_0 = max(NumDims.x_Reshape_4_output_0, NumDims.x_Constant_27_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_4_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_2_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_2_output_0);
Vars.x_Unsqueeze_4_output_0 = reshape(Vars.x_Gather_2_output_0, shape);

% Concat:
[Vars.x_Concat_6_output_0, NumDims.x_Concat_6_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_4_output_0, Vars.x_Constant_29_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_4_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Constant_29_output_0]);

% Equal:
Vars.x_Equal_output_0 = Vars.x_Concat_6_output_0 == Vars.x_Mul_3_output_0;
NumDims.x_Equal_output_0 = max(NumDims.x_Concat_6_output_0, NumDims.x_Mul_3_output_0);

% Where:
[Vars.x_Where_output_0, NumDims.x_Where_output_0] = onnxWhere(Vars.x_Equal_output_0, Vars.x_ConstantOfShape_output_0, Vars.x_Concat_6_output_0, NumDims.x_Equal_output_0, NumDims.x_ConstantOfShape_output_0, NumDims.x_Concat_6_output_0);

% Expand:
[shape, NumDims.x_Expand_2_output_0] = prepareExpandArgs(Vars.x_Where_output_0);
Vars.x_Expand_2_output_0 = Vars.x_Mul_2_output_0 + zeros(shape);

% Transpose:
[perm, NumDims.x_Transpose_output_0] = prepareTransposeArgs(Vars.TransposePerm1074, NumDims.x_net_block_fusion_block_fusion_2_Conv_o);
if ~isempty(perm)
    Vars.x_Transpose_output_0 = permute(Vars.x_net_block_fusion_block_fusion_2_Conv_o, perm);
end

% Concat:
[Vars.x_Concat_7_output_0, NumDims.x_Concat_7_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_4_output_0, Vars.x_Constant_29_output_0, Vars.x_Unsqueeze_6_output_0}, [NumDims.x_Unsqueeze_4_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Unsqueeze_6_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_6_output_0] = prepareReshapeArgs(Vars.x_Transpose_output_0, Vars.x_Concat_7_output_0, NumDims.x_Transpose_output_0, 0);
Vars.x_Reshape_6_output_0 = reshape(Vars.x_Transpose_output_0, shape{:});

% Transpose:
[perm, NumDims.x_Transpose_1_output_0] = prepareTransposeArgs(Vars.TransposePerm1075, NumDims.x_net_heatmap_head_heatmap_head_3_Sigm_1);
if ~isempty(perm)
    Vars.x_Transpose_1_output_0 = permute(Vars.x_net_heatmap_head_heatmap_head_3_Sigm_1, perm);
end

% Concat:
[Vars.x_Concat_8_output_0, NumDims.x_Concat_8_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_4_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_4_output_0, NumDims.x_Constant_29_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_7_output_0] = prepareReshapeArgs(Vars.x_Transpose_1_output_0, Vars.x_Concat_8_output_0, NumDims.x_Transpose_1_output_0, 0);
Vars.x_Reshape_7_output_0 = reshape(Vars.x_Transpose_1_output_0, shape{:});

% TopK:
[Vars.x_TopK_output_0, Vars.x_TopK_output_1, NumDims.x_TopK_output_0, NumDims.x_TopK_output_1] = onnxTopK11(Vars.x_Reshape_7_output_0, Vars.x_Constant_35_output_0, -1, 1, 1, NumDims.x_Reshape_7_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_8_output_0] = prepareUnsqueezeArgs(Vars.x_TopK_output_1, Vars.x_net_Constant_4_output_0, NumDims.x_TopK_output_1);
Vars.x_Unsqueeze_8_output_0 = reshape(Vars.x_TopK_output_1, shape);

% Expand:
[shape, NumDims.x_Expand_3_output_0] = prepareExpandArgs(Vars.x_Where_1_output_0);
Vars.x_Expand_3_output_0 = Vars.x_Unsqueeze_8_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_output_0, NumDims.x_GatherElements_output_0] = onnxGatherElements(Vars.x_Reshape_6_output_0, Vars.x_Expand_3_output_0, 1, NumDims.x_Reshape_6_output_0, NumDims.x_Expand_3_output_0);

% Expand:
[shape, NumDims.x_Expand_4_output_0] = prepareExpandArgs(Vars.x_Where_2_output_0);
Vars.x_Expand_4_output_0 = Vars.x_Unsqueeze_8_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_1_output_0, NumDims.x_GatherElements_1_output_0] = onnxGatherElements(Vars.x_Expand_2_output_0, Vars.x_Expand_4_output_0, 1, NumDims.x_Expand_2_output_0, NumDims.x_Expand_4_output_0);

% Cast:
if islogical(Vars.x_GatherElements_1_output_0)
    Vars.x_GatherElements_1_output_0 = single(Vars.x_GatherElements_1_output_0);
end
Vars.x_Cast_8_output_0 = single(Vars.x_GatherElements_1_output_0);
NumDims.x_Cast_8_output_0 = NumDims.x_GatherElements_1_output_0;

% Shape:
[Vars.x_Shape_10_output_0, NumDims.x_Shape_10_output_0] = onnxShape(Vars.x_Resize_1_output_0, NumDims.x_Resize_1_output_0, 0, NumDims.x_Resize_1_output_0+1);

% Gather:
[Vars.x_Gather_6_output_0, NumDims.x_Gather_6_output_0] = onnxGather(Vars.x_Shape_10_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_10_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_7_output_0, NumDims.x_Gather_7_output_0] = onnxGather(Vars.x_Shape_10_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_10_output_0, NumDims.x_Constant_3_output_0);

% Div:
Vars.x_Div_2_output_0 = fix(Vars.x_Gather_6_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_2_output_0 = max(NumDims.x_Gather_6_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_7_output_0 = Vars.x_Div_2_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_7_output_0 = max(NumDims.x_Div_2_output_0, NumDims.x_Constant_4_output_0);

% Div:
Vars.x_Div_3_output_0 = fix(Vars.x_Gather_7_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_3_output_0 = max(NumDims.x_Gather_7_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_8_output_0 = Vars.x_Div_3_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_8_output_0 = max(NumDims.x_Div_3_output_0, NumDims.x_Constant_4_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_9_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_7_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_7_output_0);
Vars.x_Unsqueeze_9_output_0 = reshape(Vars.x_Mul_7_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_10_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_8_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_8_output_0);
Vars.x_Unsqueeze_10_output_0 = reshape(Vars.x_Mul_8_output_0, shape);

% Concat:
[Vars.x_Concat_10_output_0, NumDims.x_Concat_10_output_0] = onnxConcat(0, {Vars.x_v_1924, Vars.x_Unsqueeze_9_output_0, Vars.x_Unsqueeze_10_output_0}, [NumDims.x_v_1924, NumDims.x_Unsqueeze_9_output_0, NumDims.x_Unsqueeze_10_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_3_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_Concat_10_output_0, "half_pixel", "linear", "floor", NumDims.x_Resize_1_output_0);
if isempty(DLTScales)
    Vars.x_Resize_3_output_0 = dlresize(Vars.x_Resize_1_output_0, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_3_output_0 = dlresize(Vars.x_Resize_1_output_0, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% ReduceMean:
dims = prepareReduceArgs(Vars.ReduceMeanAxes1076, NumDims.x_Resize_3_output_0);
Vars.x_net_1_ReduceMean_output_0 = mean(Vars.x_Resize_3_output_0, dims);
NumDims.x_net_1_ReduceMean_output_0 = NumDims.x_Resize_3_output_0;

% InstanceNormalization:
if NumDims.x_net_1_ReduceMean_output_0 > 1
    Vars.x_net_norm_1_InstanceNormalization_outpu = instancenorm(Vars.x_net_1_ReduceMean_output_0, Vars.x_net_norm_Constant_1_output_0, Vars.x_net_norm_Constant_output_0, 'Epsilon', 0.000010, 'DataFormat', [repmat('S',[1 NumDims.x_net_1_ReduceMean_output_0-2]),'CB']);
end
NumDims.x_net_norm_1_InstanceNormalization_outpu = NumDims.x_net_1_ReduceMean_output_0;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_0_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1526, Vars.onnx__Conv_1527, Vars.ConvStride1077, Vars.ConvDilationFactor1078, Vars.ConvPadding1079, 1, NumDims.x_net_norm_1_InstanceNormalization_outpu, NumDims.onnx__Conv_1526);
Vars.x_net_block1_block1_0_layer_layer_0_1__1 = dlconv(Vars.x_net_norm_1_InstanceNormalization_outpu, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_0_layer_layer_2_1__1 = relu(Vars.x_net_block1_block1_0_layer_layer_0_1__1);
NumDims.x_net_block1_block1_0_layer_layer_2_1__1 = NumDims.x_net_block1_block1_0_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_1_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1529, Vars.onnx__Conv_1530, Vars.ConvStride1080, Vars.ConvDilationFactor1081, Vars.ConvPadding1082, 1, NumDims.x_net_block1_block1_0_layer_layer_2_1__1, NumDims.onnx__Conv_1529);
Vars.x_net_block1_block1_1_layer_layer_0_1__1 = dlconv(Vars.x_net_block1_block1_0_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_1_layer_layer_2_1__1 = relu(Vars.x_net_block1_block1_1_layer_layer_0_1__1);
NumDims.x_net_block1_block1_1_layer_layer_2_1__1 = NumDims.x_net_block1_block1_1_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_2_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1532, Vars.onnx__Conv_1533, Vars.ConvStride1083, Vars.ConvDilationFactor1084, Vars.ConvPadding1085, 1, NumDims.x_net_block1_block1_1_layer_layer_2_1__1, NumDims.onnx__Conv_1532);
Vars.x_net_block1_block1_2_layer_layer_0_1__1 = dlconv(Vars.x_net_block1_block1_1_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_2_layer_layer_2_1__1 = relu(Vars.x_net_block1_block1_2_layer_layer_0_1__1);
NumDims.x_net_block1_block1_2_layer_layer_2_1__1 = NumDims.x_net_block1_block1_2_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_3_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1535, Vars.onnx__Conv_1536, Vars.ConvStride1086, Vars.ConvDilationFactor1087, Vars.ConvPadding1088, 1, NumDims.x_net_block1_block1_2_layer_layer_2_1__1, NumDims.onnx__Conv_1535);
Vars.x_net_block1_block1_3_layer_layer_0_1__1 = dlconv(Vars.x_net_block1_block1_2_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_3_layer_layer_2_1__1 = relu(Vars.x_net_block1_block1_3_layer_layer_0_1__1);
NumDims.x_net_block1_block1_3_layer_layer_2_1__1 = NumDims.x_net_block1_block1_3_layer_layer_0_1__1;

% AveragePool:
[poolSize, stride, padding, paddingValue, dataFormat, NumDims.x_net_skip1_skip1_0_1_AveragePool_output] = prepareAveragePoolArgs(Vars.AveragePoolPoolSize1089, Vars.AveragePoolStride1090, Vars.AveragePoolPadding1091, 1, NumDims.x_net_norm_1_InstanceNormalization_outpu);
Vars.x_net_skip1_skip1_0_1_AveragePool_output = avgpool(Vars.x_net_norm_1_InstanceNormalization_outpu, poolSize, 'Stride', stride, 'Padding', padding, 'PaddingValue', paddingValue, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_skip1_skip1_1_1_Conv_output_0] = prepareConvArgs(Vars.net_skip1_1_weight, Vars.net_skip1_1_bias, Vars.ConvStride1092, Vars.ConvDilationFactor1093, Vars.ConvPadding1094, 1, NumDims.x_net_skip1_skip1_0_1_AveragePool_output, NumDims.net_skip1_1_weight);
Vars.x_net_skip1_skip1_1_1_Conv_output_0 = dlconv(Vars.x_net_skip1_skip1_0_1_AveragePool_output, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Add:
Vars.x_net_1_Add_output_0 = Vars.x_net_block1_block1_3_layer_layer_2_1__1 + Vars.x_net_skip1_skip1_1_1_Conv_output_0;
NumDims.x_net_1_Add_output_0 = max(NumDims.x_net_block1_block1_3_layer_layer_2_1__1, NumDims.x_net_skip1_skip1_1_1_Conv_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_0_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1538, Vars.onnx__Conv_1539, Vars.ConvStride1095, Vars.ConvDilationFactor1096, Vars.ConvPadding1097, 1, NumDims.x_net_1_Add_output_0, NumDims.onnx__Conv_1538);
Vars.x_net_block2_block2_0_layer_layer_0_1__1 = dlconv(Vars.x_net_1_Add_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_0_layer_layer_2_1__1 = relu(Vars.x_net_block2_block2_0_layer_layer_0_1__1);
NumDims.x_net_block2_block2_0_layer_layer_2_1__1 = NumDims.x_net_block2_block2_0_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_1_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1541, Vars.onnx__Conv_1542, Vars.ConvStride1098, Vars.ConvDilationFactor1099, Vars.ConvPadding1100, 1, NumDims.x_net_block2_block2_0_layer_layer_2_1__1, NumDims.onnx__Conv_1541);
Vars.x_net_block2_block2_1_layer_layer_0_1__1 = dlconv(Vars.x_net_block2_block2_0_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_1_layer_layer_2_1__1 = relu(Vars.x_net_block2_block2_1_layer_layer_0_1__1);
NumDims.x_net_block2_block2_1_layer_layer_2_1__1 = NumDims.x_net_block2_block2_1_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_0_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1544, Vars.onnx__Conv_1545, Vars.ConvStride1101, Vars.ConvDilationFactor1102, Vars.ConvPadding1103, 1, NumDims.x_net_block2_block2_1_layer_layer_2_1__1, NumDims.onnx__Conv_1544);
Vars.x_net_block3_block3_0_layer_layer_0_1__1 = dlconv(Vars.x_net_block2_block2_1_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_0_layer_layer_2_1__1 = relu(Vars.x_net_block3_block3_0_layer_layer_0_1__1);
NumDims.x_net_block3_block3_0_layer_layer_2_1__1 = NumDims.x_net_block3_block3_0_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_1_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1547, Vars.onnx__Conv_1548, Vars.ConvStride1104, Vars.ConvDilationFactor1105, Vars.ConvPadding1106, 1, NumDims.x_net_block3_block3_0_layer_layer_2_1__1, NumDims.onnx__Conv_1547);
Vars.x_net_block3_block3_1_layer_layer_0_1__1 = dlconv(Vars.x_net_block3_block3_0_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_1_layer_layer_2_1__1 = relu(Vars.x_net_block3_block3_1_layer_layer_0_1__1);
NumDims.x_net_block3_block3_1_layer_layer_2_1__1 = NumDims.x_net_block3_block3_1_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_2_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1550, Vars.onnx__Conv_1551, Vars.ConvStride1107, Vars.ConvDilationFactor1108, Vars.ConvPadding1109, 1, NumDims.x_net_block3_block3_1_layer_layer_2_1__1, NumDims.onnx__Conv_1550);
Vars.x_net_block3_block3_2_layer_layer_0_1__1 = dlconv(Vars.x_net_block3_block3_1_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_2_layer_layer_2_1__1 = relu(Vars.x_net_block3_block3_2_layer_layer_0_1__1);
NumDims.x_net_block3_block3_2_layer_layer_2_1__1 = NumDims.x_net_block3_block3_2_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_0_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1553, Vars.onnx__Conv_1554, Vars.ConvStride1110, Vars.ConvDilationFactor1111, Vars.ConvPadding1112, 1, NumDims.x_net_block3_block3_2_layer_layer_2_1__1, NumDims.onnx__Conv_1553);
Vars.x_net_block4_block4_0_layer_layer_0_1__1 = dlconv(Vars.x_net_block3_block3_2_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_0_layer_layer_2_1__1 = relu(Vars.x_net_block4_block4_0_layer_layer_0_1__1);
NumDims.x_net_block4_block4_0_layer_layer_2_1__1 = NumDims.x_net_block4_block4_0_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_1_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1556, Vars.onnx__Conv_1557, Vars.ConvStride1113, Vars.ConvDilationFactor1114, Vars.ConvPadding1115, 1, NumDims.x_net_block4_block4_0_layer_layer_2_1__1, NumDims.onnx__Conv_1556);
Vars.x_net_block4_block4_1_layer_layer_0_1__1 = dlconv(Vars.x_net_block4_block4_0_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_1_layer_layer_2_1__1 = relu(Vars.x_net_block4_block4_1_layer_layer_0_1__1);
NumDims.x_net_block4_block4_1_layer_layer_2_1__1 = NumDims.x_net_block4_block4_1_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_2_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1559, Vars.onnx__Conv_1560, Vars.ConvStride1116, Vars.ConvDilationFactor1117, Vars.ConvPadding1118, 1, NumDims.x_net_block4_block4_1_layer_layer_2_1__1, NumDims.onnx__Conv_1559);
Vars.x_net_block4_block4_2_layer_layer_0_1__1 = dlconv(Vars.x_net_block4_block4_1_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_2_layer_layer_2_1__1 = relu(Vars.x_net_block4_block4_2_layer_layer_0_1__1);
NumDims.x_net_block4_block4_2_layer_layer_2_1__1 = NumDims.x_net_block4_block4_2_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_0_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1562, Vars.onnx__Conv_1563, Vars.ConvStride1119, Vars.ConvDilationFactor1120, Vars.ConvPadding1121, 1, NumDims.x_net_block4_block4_2_layer_layer_2_1__1, NumDims.onnx__Conv_1562);
Vars.x_net_block5_block5_0_layer_layer_0_1__1 = dlconv(Vars.x_net_block4_block4_2_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_0_layer_layer_2_1__1 = relu(Vars.x_net_block5_block5_0_layer_layer_0_1__1);
NumDims.x_net_block5_block5_0_layer_layer_2_1__1 = NumDims.x_net_block5_block5_0_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_1_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1565, Vars.onnx__Conv_1566, Vars.ConvStride1122, Vars.ConvDilationFactor1123, Vars.ConvPadding1124, 1, NumDims.x_net_block5_block5_0_layer_layer_2_1__1, NumDims.onnx__Conv_1565);
Vars.x_net_block5_block5_1_layer_layer_0_1__1 = dlconv(Vars.x_net_block5_block5_0_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_1_layer_layer_2_1__1 = relu(Vars.x_net_block5_block5_1_layer_layer_0_1__1);
NumDims.x_net_block5_block5_1_layer_layer_2_1__1 = NumDims.x_net_block5_block5_1_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_2_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1568, Vars.onnx__Conv_1569, Vars.ConvStride1125, Vars.ConvDilationFactor1126, Vars.ConvPadding1127, 1, NumDims.x_net_block5_block5_1_layer_layer_2_1__1, NumDims.onnx__Conv_1568);
Vars.x_net_block5_block5_2_layer_layer_0_1__1 = dlconv(Vars.x_net_block5_block5_1_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_2_layer_layer_2_1__1 = relu(Vars.x_net_block5_block5_2_layer_layer_0_1__1);
NumDims.x_net_block5_block5_2_layer_layer_2_1__1 = NumDims.x_net_block5_block5_2_layer_layer_0_1__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_3_layer_layer_0_1__1] = prepareConvArgs(Vars.onnx__Conv_1571, Vars.onnx__Conv_1572, Vars.ConvStride1128, Vars.ConvDilationFactor1129, Vars.ConvPadding1130, 1, NumDims.x_net_block5_block5_2_layer_layer_2_1__1, NumDims.onnx__Conv_1571);
Vars.x_net_block5_block5_3_layer_layer_0_1__1 = dlconv(Vars.x_net_block5_block5_2_layer_layer_2_1__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_3_layer_layer_2_1__1 = relu(Vars.x_net_block5_block5_3_layer_layer_0_1__1);
NumDims.x_net_block5_block5_3_layer_layer_2_1__1 = NumDims.x_net_block5_block5_3_layer_layer_0_1__1;

% Shape:
[Vars.x_net_1_Shape_output_0, NumDims.x_net_1_Shape_output_0] = onnxShape(Vars.x_net_block3_block3_2_layer_layer_2_1__1, NumDims.x_net_block3_block3_2_layer_layer_2_1__1, 0, NumDims.x_net_block3_block3_2_layer_layer_2_1__1+1);

% Gather:
[Vars.x_net_1_Gather_output_0, NumDims.x_net_1_Gather_output_0] = onnxGather(Vars.x_net_1_Shape_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_net_1_Shape_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_net_1_Gather_1_output_0, NumDims.x_net_1_Gather_1_output_0] = onnxGather(Vars.x_net_1_Shape_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_net_1_Shape_output_0, NumDims.x_Constant_3_output_0);

% Unsqueeze:
[shape, NumDims.x_net_1_Unsqueeze_output_0] = prepareUnsqueezeArgs(Vars.x_net_1_Gather_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_1_Gather_output_0);
Vars.x_net_1_Unsqueeze_output_0 = reshape(Vars.x_net_1_Gather_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_net_1_Unsqueeze_1_output_0] = prepareUnsqueezeArgs(Vars.x_net_1_Gather_1_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_1_Gather_1_output_0);
Vars.x_net_1_Unsqueeze_1_output_0 = reshape(Vars.x_net_1_Gather_1_output_0, shape);

% Shape:
[Vars.x_net_1_Shape_2_output_0, NumDims.x_net_1_Shape_2_output_0] = onnxShape(Vars.x_net_block4_block4_2_layer_layer_2_1__1, NumDims.x_net_block4_block4_2_layer_layer_2_1__1, 0, NumDims.x_net_block4_block4_2_layer_layer_2_1__1+1);

% Slice:
[Indices, NumDims.x_net_1_Slice_output_0] = prepareSliceArgs(Vars.x_net_1_Shape_2_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_1_Shape_2_output_0);
Vars.x_net_1_Slice_output_0 = subsref(Vars.x_net_1_Shape_2_output_0, Indices);

% Concat:
[Vars.x_net_1_Concat_1_output_0, NumDims.x_net_1_Concat_1_output_0] = onnxConcat(0, {Vars.x_net_1_Slice_output_0, Vars.x_net_1_Unsqueeze_output_0, Vars.x_net_1_Unsqueeze_1_output_0}, [NumDims.x_net_1_Slice_output_0, NumDims.x_net_1_Unsqueeze_output_0, NumDims.x_net_1_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_1_Resize_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_1_Concat_1_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block4_block4_2_layer_layer_2_1__1);
if isempty(DLTScales)
    Vars.x_net_1_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_1__1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_1_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_1__1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Shape:
[Vars.x_net_1_Shape_5_output_0, NumDims.x_net_1_Shape_5_output_0] = onnxShape(Vars.x_net_block5_block5_3_layer_layer_2_1__1, NumDims.x_net_block5_block5_3_layer_layer_2_1__1, 0, NumDims.x_net_block5_block5_3_layer_layer_2_1__1+1);

% Slice:
[Indices, NumDims.x_net_1_Slice_1_output_0] = prepareSliceArgs(Vars.x_net_1_Shape_5_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_1_Shape_5_output_0);
Vars.x_net_1_Slice_1_output_0 = subsref(Vars.x_net_1_Shape_5_output_0, Indices);

% Concat:
[Vars.x_net_1_Concat_3_output_0, NumDims.x_net_1_Concat_3_output_0] = onnxConcat(0, {Vars.x_net_1_Slice_1_output_0, Vars.x_net_1_Unsqueeze_output_0, Vars.x_net_1_Unsqueeze_1_output_0}, [NumDims.x_net_1_Slice_1_output_0, NumDims.x_net_1_Unsqueeze_output_0, NumDims.x_net_1_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_1_Resize_1_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_1_Concat_3_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block5_block5_3_layer_layer_2_1__1);
if isempty(DLTScales)
    Vars.x_net_1_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_1__1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_1_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_1__1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Add:
Vars.x_net_1_Add_1_output_0 = Vars.x_net_block3_block3_2_layer_layer_2_1__1 + Vars.x_net_1_Resize_output_0;
NumDims.x_net_1_Add_1_output_0 = max(NumDims.x_net_block3_block3_2_layer_layer_2_1__1, NumDims.x_net_1_Resize_output_0);

% Add:
Vars.x_net_1_Add_2_output_0 = Vars.x_net_1_Add_1_output_0 + Vars.x_net_1_Resize_1_output_0;
NumDims.x_net_1_Add_2_output_0 = max(NumDims.x_net_1_Add_1_output_0, NumDims.x_net_1_Resize_1_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_0_lay_3] = prepareConvArgs(Vars.onnx__Conv_1574, Vars.onnx__Conv_1575, Vars.ConvStride1131, Vars.ConvDilationFactor1132, Vars.ConvPadding1133, 1, NumDims.x_net_1_Add_2_output_0, NumDims.onnx__Conv_1574);
Vars.x_net_block_fusion_block_fusion_0_lay_3 = dlconv(Vars.x_net_1_Add_2_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_0_lay_11 = relu(Vars.x_net_block_fusion_block_fusion_0_lay_3);
NumDims.x_net_block_fusion_block_fusion_0_lay_11 = NumDims.x_net_block_fusion_block_fusion_0_lay_3;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_1_lay_3] = prepareConvArgs(Vars.onnx__Conv_1577, Vars.onnx__Conv_1578, Vars.ConvStride1134, Vars.ConvDilationFactor1135, Vars.ConvPadding1136, 1, NumDims.x_net_block_fusion_block_fusion_0_lay_11, NumDims.onnx__Conv_1577);
Vars.x_net_block_fusion_block_fusion_1_lay_3 = dlconv(Vars.x_net_block_fusion_block_fusion_0_lay_11, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_1_lay_11 = relu(Vars.x_net_block_fusion_block_fusion_1_lay_3);
NumDims.x_net_block_fusion_block_fusion_1_lay_11 = NumDims.x_net_block_fusion_block_fusion_1_lay_3;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_2_1_Co_1] = prepareConvArgs(Vars.net_block_fusion_2_weight, Vars.net_block_fusion_2_bias, Vars.ConvStride1137, Vars.ConvDilationFactor1138, Vars.ConvPadding1139, 1, NumDims.x_net_block_fusion_block_fusion_1_lay_11, NumDims.net_block_fusion_2_weight);
Vars.x_net_block_fusion_block_fusion_2_1_Co_1 = dlconv(Vars.x_net_block_fusion_block_fusion_1_lay_11, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_0_lay_3] = prepareConvArgs(Vars.onnx__Conv_1580, Vars.onnx__Conv_1581, Vars.ConvStride1140, Vars.ConvDilationFactor1141, Vars.ConvPadding1142, 1, NumDims.x_net_block_fusion_block_fusion_2_1_Co_1, NumDims.onnx__Conv_1580);
Vars.x_net_heatmap_head_heatmap_head_0_lay_3 = dlconv(Vars.x_net_block_fusion_block_fusion_2_1_Co_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_0_lay_11 = relu(Vars.x_net_heatmap_head_heatmap_head_0_lay_3);
NumDims.x_net_heatmap_head_heatmap_head_0_lay_11 = NumDims.x_net_heatmap_head_heatmap_head_0_lay_3;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_1_lay_3] = prepareConvArgs(Vars.onnx__Conv_1583, Vars.onnx__Conv_1584, Vars.ConvStride1143, Vars.ConvDilationFactor1144, Vars.ConvPadding1145, 1, NumDims.x_net_heatmap_head_heatmap_head_0_lay_11, NumDims.onnx__Conv_1583);
Vars.x_net_heatmap_head_heatmap_head_1_lay_3 = dlconv(Vars.x_net_heatmap_head_heatmap_head_0_lay_11, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_1_lay_11 = relu(Vars.x_net_heatmap_head_heatmap_head_1_lay_3);
NumDims.x_net_heatmap_head_heatmap_head_1_lay_11 = NumDims.x_net_heatmap_head_heatmap_head_1_lay_3;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_2_1_Co_1] = prepareConvArgs(Vars.net_heatmap_head_2_weight, Vars.net_heatmap_head_2_bias, Vars.ConvStride1146, Vars.ConvDilationFactor1147, Vars.ConvPadding1148, 1, NumDims.x_net_heatmap_head_heatmap_head_1_lay_11, NumDims.net_heatmap_head_2_weight);
Vars.x_net_heatmap_head_heatmap_head_2_1_Co_1 = dlconv(Vars.x_net_heatmap_head_heatmap_head_1_lay_11, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Sigmoid:
Vars.x_net_heatmap_head_heatmap_head_3_1_Si_1 = sigmoid(Vars.x_net_heatmap_head_heatmap_head_2_1_Co_1);
NumDims.x_net_heatmap_head_heatmap_head_3_1_Si_1 = NumDims.x_net_heatmap_head_heatmap_head_2_1_Co_1;

% Shape:
[Vars.x_Shape_13_output_0, NumDims.x_Shape_13_output_0] = onnxShape(Vars.x_net_block_fusion_block_fusion_2_1_Co_1, NumDims.x_net_block_fusion_block_fusion_2_1_Co_1, 0, NumDims.x_net_block_fusion_block_fusion_2_1_Co_1+1);

% Gather:
[Vars.x_Gather_8_output_0, NumDims.x_Gather_8_output_0] = onnxGather(Vars.x_Shape_13_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Shape_13_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_10_output_0, NumDims.x_Gather_10_output_0] = onnxGather(Vars.x_Shape_13_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_13_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_11_output_0, NumDims.x_Gather_11_output_0] = onnxGather(Vars.x_Shape_13_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_13_output_0, NumDims.x_Constant_3_output_0);

% Range:
Vars.x_Range_2_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_10_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_2_output_0 = 1;

% Range:
Vars.x_Range_3_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_11_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_3_output_0 = 1;

% Shape:
[Vars.x_Shape_17_output_0, NumDims.x_Shape_17_output_0] = onnxShape(Vars.x_Range_2_output_0, NumDims.x_Range_2_output_0, 0, NumDims.x_Range_2_output_0+1);

% Shape:
[Vars.x_Shape_18_output_0, NumDims.x_Shape_18_output_0] = onnxShape(Vars.x_Range_3_output_0, NumDims.x_Range_3_output_0, 0, NumDims.x_Range_3_output_0+1);

% Concat:
[Vars.x_Concat_11_output_0, NumDims.x_Concat_11_output_0] = onnxConcat(0, {Vars.x_Shape_17_output_0, Vars.x_Shape_18_output_0}, [NumDims.x_Shape_17_output_0, NumDims.x_Shape_18_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_10_output_0] = prepareReshapeArgs(Vars.x_Range_2_output_0, Vars.x_v_1932, NumDims.x_Range_2_output_0, 0);
Vars.x_Reshape_10_output_0 = reshape(Vars.x_Range_2_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_5_output_0] = prepareExpandArgs(Vars.x_Concat_11_output_0);
Vars.x_Expand_5_output_0 = Vars.x_Reshape_10_output_0 + zeros(shape);

% Reshape:
[shape, NumDims.x_Reshape_11_output_0] = prepareReshapeArgs(Vars.x_Range_3_output_0, Vars.x_v_1934, NumDims.x_Range_3_output_0, 0);
Vars.x_Reshape_11_output_0 = reshape(Vars.x_Range_3_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_6_output_0] = prepareExpandArgs(Vars.x_Concat_11_output_0);
Vars.x_Expand_6_output_0 = Vars.x_Reshape_11_output_0 + zeros(shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_11_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_6_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_6_output_0);
Vars.x_Unsqueeze_11_output_0 = reshape(Vars.x_Expand_6_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_12_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_5_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_5_output_0);
Vars.x_Unsqueeze_12_output_0 = reshape(Vars.x_Expand_5_output_0, shape);

% Concat:
[Vars.x_Concat_14_output_0, NumDims.x_Concat_14_output_0] = onnxConcat(-1, {Vars.x_Unsqueeze_11_output_0, Vars.x_Unsqueeze_12_output_0}, [NumDims.x_Unsqueeze_11_output_0, NumDims.x_Unsqueeze_12_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_12_output_0] = prepareReshapeArgs(Vars.x_Concat_14_output_0, Vars.x_Constant_26_output_0, NumDims.x_Concat_14_output_0, 0);
Vars.x_Reshape_12_output_0 = reshape(Vars.x_Concat_14_output_0, shape{:});

% Mul:
Vars.x_Mul_9_output_0 = Vars.x_Reshape_12_output_0 .* Vars.x_Constant_27_output_0;
NumDims.x_Mul_9_output_0 = max(NumDims.x_Reshape_12_output_0, NumDims.x_Constant_27_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_13_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_8_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_8_output_0);
Vars.x_Unsqueeze_13_output_0 = reshape(Vars.x_Gather_8_output_0, shape);

% Concat:
[Vars.x_Concat_15_output_0, NumDims.x_Concat_15_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_13_output_0, Vars.x_Constant_29_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_13_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Constant_29_output_0]);

% Equal:
Vars.x_Equal_3_output_0 = Vars.x_Concat_15_output_0 == Vars.x_Mul_3_output_0;
NumDims.x_Equal_3_output_0 = max(NumDims.x_Concat_15_output_0, NumDims.x_Mul_3_output_0);

% Where:
[Vars.x_Where_3_output_0, NumDims.x_Where_3_output_0] = onnxWhere(Vars.x_Equal_3_output_0, Vars.x_ConstantOfShape_output_0, Vars.x_Concat_15_output_0, NumDims.x_Equal_3_output_0, NumDims.x_ConstantOfShape_output_0, NumDims.x_Concat_15_output_0);

% Expand:
[shape, NumDims.x_Expand_7_output_0] = prepareExpandArgs(Vars.x_Where_3_output_0);
Vars.x_Expand_7_output_0 = Vars.x_Mul_9_output_0 + zeros(shape);

% Transpose:
[perm, NumDims.x_Transpose_2_output_0] = prepareTransposeArgs(Vars.TransposePerm1149, NumDims.x_net_block_fusion_block_fusion_2_1_Co_1);
if ~isempty(perm)
    Vars.x_Transpose_2_output_0 = permute(Vars.x_net_block_fusion_block_fusion_2_1_Co_1, perm);
end

% Concat:
[Vars.x_Concat_16_output_0, NumDims.x_Concat_16_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_13_output_0, Vars.x_Constant_29_output_0, Vars.x_Unsqueeze_6_output_0}, [NumDims.x_Unsqueeze_13_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Unsqueeze_6_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_14_output_0] = prepareReshapeArgs(Vars.x_Transpose_2_output_0, Vars.x_Concat_16_output_0, NumDims.x_Transpose_2_output_0, 0);
Vars.x_Reshape_14_output_0 = reshape(Vars.x_Transpose_2_output_0, shape{:});

% Transpose:
[perm, NumDims.x_Transpose_3_output_0] = prepareTransposeArgs(Vars.TransposePerm1150, NumDims.x_net_heatmap_head_heatmap_head_3_1_Si_1);
if ~isempty(perm)
    Vars.x_Transpose_3_output_0 = permute(Vars.x_net_heatmap_head_heatmap_head_3_1_Si_1, perm);
end

% Concat:
[Vars.x_Concat_17_output_0, NumDims.x_Concat_17_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_13_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_13_output_0, NumDims.x_Constant_29_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_15_output_0] = prepareReshapeArgs(Vars.x_Transpose_3_output_0, Vars.x_Concat_17_output_0, NumDims.x_Transpose_3_output_0, 0);
Vars.x_Reshape_15_output_0 = reshape(Vars.x_Transpose_3_output_0, shape{:});

% TopK:
[Vars.x_TopK_1_output_0, Vars.x_TopK_1_output_1, NumDims.x_TopK_1_output_0, NumDims.x_TopK_1_output_1] = onnxTopK11(Vars.x_Reshape_15_output_0, Vars.x_Constant_78_output_0, -1, 1, 1, NumDims.x_Reshape_15_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_17_output_0] = prepareUnsqueezeArgs(Vars.x_TopK_1_output_1, Vars.x_net_Constant_4_output_0, NumDims.x_TopK_1_output_1);
Vars.x_Unsqueeze_17_output_0 = reshape(Vars.x_TopK_1_output_1, shape);

% Expand:
[shape, NumDims.x_Expand_8_output_0] = prepareExpandArgs(Vars.x_Where_1_output_0);
Vars.x_Expand_8_output_0 = Vars.x_Unsqueeze_17_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_2_output_0, NumDims.x_GatherElements_2_output_0] = onnxGatherElements(Vars.x_Reshape_14_output_0, Vars.x_Expand_8_output_0, 1, NumDims.x_Reshape_14_output_0, NumDims.x_Expand_8_output_0);

% Expand:
[shape, NumDims.x_Expand_9_output_0] = prepareExpandArgs(Vars.x_Where_2_output_0);
Vars.x_Expand_9_output_0 = Vars.x_Unsqueeze_17_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_3_output_0, NumDims.x_GatherElements_3_output_0] = onnxGatherElements(Vars.x_Expand_7_output_0, Vars.x_Expand_9_output_0, 1, NumDims.x_Expand_7_output_0, NumDims.x_Expand_9_output_0);

% Cast:
if islogical(Vars.x_GatherElements_3_output_0)
    Vars.x_GatherElements_3_output_0 = single(Vars.x_GatherElements_3_output_0);
end
Vars.x_Cast_17_output_0 = single(Vars.x_GatherElements_3_output_0);
NumDims.x_Cast_17_output_0 = NumDims.x_GatherElements_3_output_0;

% Div:
Vars.x_Div_4_output_0 = Vars.x_Cast_8_output_0 ./ Vars.x_Constant_89_output_0;
NumDims.x_Div_4_output_0 = max(NumDims.x_Cast_8_output_0, NumDims.x_Constant_89_output_0);

% Div:
Vars.x_Div_5_output_0 = Vars.x_Cast_17_output_0 ./ Vars.x_Constant_90_output_0;
NumDims.x_Div_5_output_0 = max(NumDims.x_Cast_17_output_0, NumDims.x_Constant_90_output_0);

% Concat:
[Vars.x_Concat_18_output_0, NumDims.x_Concat_18_output_0] = onnxConcat(1, {Vars.x_Div_4_output_0, Vars.x_Div_5_output_0}, [NumDims.x_Div_4_output_0, NumDims.x_Div_5_output_0]);

% Shape:
[Vars.x_Shape_20_output_0, NumDims.x_Shape_20_output_0] = onnxShape(Vars.x_Cast_8_output_0, NumDims.x_Cast_8_output_0, 0, NumDims.x_Cast_8_output_0+1);

% Gather:
[Vars.x_Gather_12_output_0, NumDims.x_Gather_12_output_0] = onnxGather(Vars.x_Shape_20_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Shape_20_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_13_output_0, NumDims.x_Gather_13_output_0] = onnxGather(Vars.x_Shape_20_output_0, Vars.x_Constant_17_output_0, 0, NumDims.x_Shape_20_output_0, NumDims.x_Constant_17_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_18_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_12_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_12_output_0);
Vars.x_Unsqueeze_18_output_0 = reshape(Vars.x_Gather_12_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_19_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_13_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_13_output_0);
Vars.x_Unsqueeze_19_output_0 = reshape(Vars.x_Gather_13_output_0, shape);

% Concat:
[Vars.x_Concat_19_output_0, NumDims.x_Concat_19_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_18_output_0, Vars.x_Unsqueeze_19_output_0}, [NumDims.x_Unsqueeze_18_output_0, NumDims.x_Unsqueeze_19_output_0]);

% ConstantOfShape:
[Vars.x_ConstantOfShape_6_output_0, NumDims.x_ConstantOfShape_6_output_0] = onnxConstantOfShape(Vars.ConstantOfShapeValue1151, Vars.x_Concat_19_output_0);

% Mul:
Vars.x_Mul_14_output_0 = Vars.x_ConstantOfShape_6_output_0 .* Vars.x_Constant_93_output_0;
NumDims.x_Mul_14_output_0 = max(NumDims.x_ConstantOfShape_6_output_0, NumDims.x_Constant_93_output_0);

% Shape:
[Vars.x_Shape_22_output_0, NumDims.x_Shape_22_output_0] = onnxShape(Vars.x_Cast_17_output_0, NumDims.x_Cast_17_output_0, 0, NumDims.x_Cast_17_output_0+1);

% Gather:
[Vars.x_Gather_14_output_0, NumDims.x_Gather_14_output_0] = onnxGather(Vars.x_Shape_22_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Shape_22_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_15_output_0, NumDims.x_Gather_15_output_0] = onnxGather(Vars.x_Shape_22_output_0, Vars.x_Constant_17_output_0, 0, NumDims.x_Shape_22_output_0, NumDims.x_Constant_17_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_20_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_14_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_14_output_0);
Vars.x_Unsqueeze_20_output_0 = reshape(Vars.x_Gather_14_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_21_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_15_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_15_output_0);
Vars.x_Unsqueeze_21_output_0 = reshape(Vars.x_Gather_15_output_0, shape);

% Concat:
[Vars.x_Concat_20_output_0, NumDims.x_Concat_20_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_20_output_0, Vars.x_Unsqueeze_21_output_0}, [NumDims.x_Unsqueeze_20_output_0, NumDims.x_Unsqueeze_21_output_0]);

% ConstantOfShape:
[Vars.x_ConstantOfShape_7_output_0, NumDims.x_ConstantOfShape_7_output_0] = onnxConstantOfShape(Vars.ConstantOfShapeValue1152, Vars.x_Concat_20_output_0);

% Mul:
Vars.x_Mul_15_output_0 = Vars.x_ConstantOfShape_7_output_0 .* Vars.x_Constant_96_output_0;
NumDims.x_Mul_15_output_0 = max(NumDims.x_ConstantOfShape_7_output_0, NumDims.x_Constant_96_output_0);

% Concat:
[Vars.x_Concat_21_output_0, NumDims.x_Concat_21_output_0] = onnxConcat(1, {Vars.x_Mul_14_output_0, Vars.x_Mul_15_output_0}, [NumDims.x_Mul_14_output_0, NumDims.x_Mul_15_output_0]);

% Concat:
[Vars.x_Concat_22_output_0, NumDims.x_Concat_22_output_0] = onnxConcat(1, {Vars.x_GatherElements_output_0, Vars.x_GatherElements_2_output_0}, [NumDims.x_GatherElements_output_0, NumDims.x_GatherElements_2_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_4_output_0] = prepareResize11Args(dlarray([]), Vars.x_Constant_output_0, dlarray([]), "half_pixel", "linear", "floor", NumDims.input2);
if isempty(DLTScales)
    Vars.x_Resize_4_output_0 = dlresize(Vars.input2, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_4_output_0 = dlresize(Vars.input2, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_5_output_0] = prepareResize11Args(dlarray([]), Vars.x_Constant_1_output_0, dlarray([]), "half_pixel", "linear", "floor", NumDims.input2);
if isempty(DLTScales)
    Vars.x_Resize_5_output_0 = dlresize(Vars.input2, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_5_output_0 = dlresize(Vars.input2, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Shape:
[Vars.x_Shape_24_output_0, NumDims.x_Shape_24_output_0] = onnxShape(Vars.x_Resize_4_output_0, NumDims.x_Resize_4_output_0, 0, NumDims.x_Resize_4_output_0+1);

% Gather:
[Vars.x_Gather_16_output_0, NumDims.x_Gather_16_output_0] = onnxGather(Vars.x_Shape_24_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_24_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_17_output_0, NumDims.x_Gather_17_output_0] = onnxGather(Vars.x_Shape_24_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_24_output_0, NumDims.x_Constant_3_output_0);

% Div:
Vars.x_Div_6_output_0 = fix(Vars.x_Gather_16_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_6_output_0 = max(NumDims.x_Gather_16_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_16_output_0 = Vars.x_Div_6_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_16_output_0 = max(NumDims.x_Div_6_output_0, NumDims.x_Constant_4_output_0);

% Div:
Vars.x_Div_7_output_0 = fix(Vars.x_Gather_17_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_7_output_0 = max(NumDims.x_Gather_17_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_17_output_0 = Vars.x_Div_7_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_17_output_0 = max(NumDims.x_Div_7_output_0, NumDims.x_Constant_4_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_22_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_16_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_16_output_0);
Vars.x_Unsqueeze_22_output_0 = reshape(Vars.x_Mul_16_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_23_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_17_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_17_output_0);
Vars.x_Unsqueeze_23_output_0 = reshape(Vars.x_Mul_17_output_0, shape);

% Concat:
[Vars.x_Concat_24_output_0, NumDims.x_Concat_24_output_0] = onnxConcat(0, {Vars.x_v_1924, Vars.x_Unsqueeze_22_output_0, Vars.x_Unsqueeze_23_output_0}, [NumDims.x_v_1924, NumDims.x_Unsqueeze_22_output_0, NumDims.x_Unsqueeze_23_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_6_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_Concat_24_output_0, "half_pixel", "linear", "floor", NumDims.x_Resize_4_output_0);
if isempty(DLTScales)
    Vars.x_Resize_6_output_0 = dlresize(Vars.x_Resize_4_output_0, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_6_output_0 = dlresize(Vars.x_Resize_4_output_0, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% ReduceMean:
dims = prepareReduceArgs(Vars.ReduceMeanAxes1153, NumDims.x_Resize_6_output_0);
Vars.x_net_2_ReduceMean_output_0 = mean(Vars.x_Resize_6_output_0, dims);
NumDims.x_net_2_ReduceMean_output_0 = NumDims.x_Resize_6_output_0;

% InstanceNormalization:
if NumDims.x_net_2_ReduceMean_output_0 > 1
    Vars.x_net_norm_2_InstanceNormalization_outpu = instancenorm(Vars.x_net_2_ReduceMean_output_0, Vars.x_net_norm_Constant_1_output_0, Vars.x_net_norm_Constant_output_0, 'Epsilon', 0.000010, 'DataFormat', [repmat('S',[1 NumDims.x_net_2_ReduceMean_output_0-2]),'CB']);
end
NumDims.x_net_norm_2_InstanceNormalization_outpu = NumDims.x_net_2_ReduceMean_output_0;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_0_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1526, Vars.onnx__Conv_1527, Vars.ConvStride1154, Vars.ConvDilationFactor1155, Vars.ConvPadding1156, 1, NumDims.x_net_norm_2_InstanceNormalization_outpu, NumDims.onnx__Conv_1526);
Vars.x_net_block1_block1_0_layer_layer_0_2__1 = dlconv(Vars.x_net_norm_2_InstanceNormalization_outpu, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_0_layer_layer_2_2__1 = relu(Vars.x_net_block1_block1_0_layer_layer_0_2__1);
NumDims.x_net_block1_block1_0_layer_layer_2_2__1 = NumDims.x_net_block1_block1_0_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_1_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1529, Vars.onnx__Conv_1530, Vars.ConvStride1157, Vars.ConvDilationFactor1158, Vars.ConvPadding1159, 1, NumDims.x_net_block1_block1_0_layer_layer_2_2__1, NumDims.onnx__Conv_1529);
Vars.x_net_block1_block1_1_layer_layer_0_2__1 = dlconv(Vars.x_net_block1_block1_0_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_1_layer_layer_2_2__1 = relu(Vars.x_net_block1_block1_1_layer_layer_0_2__1);
NumDims.x_net_block1_block1_1_layer_layer_2_2__1 = NumDims.x_net_block1_block1_1_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_2_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1532, Vars.onnx__Conv_1533, Vars.ConvStride1160, Vars.ConvDilationFactor1161, Vars.ConvPadding1162, 1, NumDims.x_net_block1_block1_1_layer_layer_2_2__1, NumDims.onnx__Conv_1532);
Vars.x_net_block1_block1_2_layer_layer_0_2__1 = dlconv(Vars.x_net_block1_block1_1_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_2_layer_layer_2_2__1 = relu(Vars.x_net_block1_block1_2_layer_layer_0_2__1);
NumDims.x_net_block1_block1_2_layer_layer_2_2__1 = NumDims.x_net_block1_block1_2_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_3_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1535, Vars.onnx__Conv_1536, Vars.ConvStride1163, Vars.ConvDilationFactor1164, Vars.ConvPadding1165, 1, NumDims.x_net_block1_block1_2_layer_layer_2_2__1, NumDims.onnx__Conv_1535);
Vars.x_net_block1_block1_3_layer_layer_0_2__1 = dlconv(Vars.x_net_block1_block1_2_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_3_layer_layer_2_2__1 = relu(Vars.x_net_block1_block1_3_layer_layer_0_2__1);
NumDims.x_net_block1_block1_3_layer_layer_2_2__1 = NumDims.x_net_block1_block1_3_layer_layer_0_2__1;

% AveragePool:
[poolSize, stride, padding, paddingValue, dataFormat, NumDims.x_net_skip1_skip1_0_2_AveragePool_output] = prepareAveragePoolArgs(Vars.AveragePoolPoolSize1166, Vars.AveragePoolStride1167, Vars.AveragePoolPadding1168, 1, NumDims.x_net_norm_2_InstanceNormalization_outpu);
Vars.x_net_skip1_skip1_0_2_AveragePool_output = avgpool(Vars.x_net_norm_2_InstanceNormalization_outpu, poolSize, 'Stride', stride, 'Padding', padding, 'PaddingValue', paddingValue, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_skip1_skip1_1_2_Conv_output_0] = prepareConvArgs(Vars.net_skip1_1_weight, Vars.net_skip1_1_bias, Vars.ConvStride1169, Vars.ConvDilationFactor1170, Vars.ConvPadding1171, 1, NumDims.x_net_skip1_skip1_0_2_AveragePool_output, NumDims.net_skip1_1_weight);
Vars.x_net_skip1_skip1_1_2_Conv_output_0 = dlconv(Vars.x_net_skip1_skip1_0_2_AveragePool_output, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Add:
Vars.x_net_2_Add_output_0 = Vars.x_net_block1_block1_3_layer_layer_2_2__1 + Vars.x_net_skip1_skip1_1_2_Conv_output_0;
NumDims.x_net_2_Add_output_0 = max(NumDims.x_net_block1_block1_3_layer_layer_2_2__1, NumDims.x_net_skip1_skip1_1_2_Conv_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_0_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1538, Vars.onnx__Conv_1539, Vars.ConvStride1172, Vars.ConvDilationFactor1173, Vars.ConvPadding1174, 1, NumDims.x_net_2_Add_output_0, NumDims.onnx__Conv_1538);
Vars.x_net_block2_block2_0_layer_layer_0_2__1 = dlconv(Vars.x_net_2_Add_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_0_layer_layer_2_2__1 = relu(Vars.x_net_block2_block2_0_layer_layer_0_2__1);
NumDims.x_net_block2_block2_0_layer_layer_2_2__1 = NumDims.x_net_block2_block2_0_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_1_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1541, Vars.onnx__Conv_1542, Vars.ConvStride1175, Vars.ConvDilationFactor1176, Vars.ConvPadding1177, 1, NumDims.x_net_block2_block2_0_layer_layer_2_2__1, NumDims.onnx__Conv_1541);
Vars.x_net_block2_block2_1_layer_layer_0_2__1 = dlconv(Vars.x_net_block2_block2_0_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_1_layer_layer_2_2__1 = relu(Vars.x_net_block2_block2_1_layer_layer_0_2__1);
NumDims.x_net_block2_block2_1_layer_layer_2_2__1 = NumDims.x_net_block2_block2_1_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_0_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1544, Vars.onnx__Conv_1545, Vars.ConvStride1178, Vars.ConvDilationFactor1179, Vars.ConvPadding1180, 1, NumDims.x_net_block2_block2_1_layer_layer_2_2__1, NumDims.onnx__Conv_1544);
Vars.x_net_block3_block3_0_layer_layer_0_2__1 = dlconv(Vars.x_net_block2_block2_1_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_0_layer_layer_2_2__1 = relu(Vars.x_net_block3_block3_0_layer_layer_0_2__1);
NumDims.x_net_block3_block3_0_layer_layer_2_2__1 = NumDims.x_net_block3_block3_0_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_1_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1547, Vars.onnx__Conv_1548, Vars.ConvStride1181, Vars.ConvDilationFactor1182, Vars.ConvPadding1183, 1, NumDims.x_net_block3_block3_0_layer_layer_2_2__1, NumDims.onnx__Conv_1547);
Vars.x_net_block3_block3_1_layer_layer_0_2__1 = dlconv(Vars.x_net_block3_block3_0_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_1_layer_layer_2_2__1 = relu(Vars.x_net_block3_block3_1_layer_layer_0_2__1);
NumDims.x_net_block3_block3_1_layer_layer_2_2__1 = NumDims.x_net_block3_block3_1_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_2_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1550, Vars.onnx__Conv_1551, Vars.ConvStride1184, Vars.ConvDilationFactor1185, Vars.ConvPadding1186, 1, NumDims.x_net_block3_block3_1_layer_layer_2_2__1, NumDims.onnx__Conv_1550);
Vars.x_net_block3_block3_2_layer_layer_0_2__1 = dlconv(Vars.x_net_block3_block3_1_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_2_layer_layer_2_2__1 = relu(Vars.x_net_block3_block3_2_layer_layer_0_2__1);
NumDims.x_net_block3_block3_2_layer_layer_2_2__1 = NumDims.x_net_block3_block3_2_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_0_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1553, Vars.onnx__Conv_1554, Vars.ConvStride1187, Vars.ConvDilationFactor1188, Vars.ConvPadding1189, 1, NumDims.x_net_block3_block3_2_layer_layer_2_2__1, NumDims.onnx__Conv_1553);
Vars.x_net_block4_block4_0_layer_layer_0_2__1 = dlconv(Vars.x_net_block3_block3_2_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_0_layer_layer_2_2__1 = relu(Vars.x_net_block4_block4_0_layer_layer_0_2__1);
NumDims.x_net_block4_block4_0_layer_layer_2_2__1 = NumDims.x_net_block4_block4_0_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_1_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1556, Vars.onnx__Conv_1557, Vars.ConvStride1190, Vars.ConvDilationFactor1191, Vars.ConvPadding1192, 1, NumDims.x_net_block4_block4_0_layer_layer_2_2__1, NumDims.onnx__Conv_1556);
Vars.x_net_block4_block4_1_layer_layer_0_2__1 = dlconv(Vars.x_net_block4_block4_0_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_1_layer_layer_2_2__1 = relu(Vars.x_net_block4_block4_1_layer_layer_0_2__1);
NumDims.x_net_block4_block4_1_layer_layer_2_2__1 = NumDims.x_net_block4_block4_1_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_2_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1559, Vars.onnx__Conv_1560, Vars.ConvStride1193, Vars.ConvDilationFactor1194, Vars.ConvPadding1195, 1, NumDims.x_net_block4_block4_1_layer_layer_2_2__1, NumDims.onnx__Conv_1559);
Vars.x_net_block4_block4_2_layer_layer_0_2__1 = dlconv(Vars.x_net_block4_block4_1_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_2_layer_layer_2_2__1 = relu(Vars.x_net_block4_block4_2_layer_layer_0_2__1);
NumDims.x_net_block4_block4_2_layer_layer_2_2__1 = NumDims.x_net_block4_block4_2_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_0_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1562, Vars.onnx__Conv_1563, Vars.ConvStride1196, Vars.ConvDilationFactor1197, Vars.ConvPadding1198, 1, NumDims.x_net_block4_block4_2_layer_layer_2_2__1, NumDims.onnx__Conv_1562);
Vars.x_net_block5_block5_0_layer_layer_0_2__1 = dlconv(Vars.x_net_block4_block4_2_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_0_layer_layer_2_2__1 = relu(Vars.x_net_block5_block5_0_layer_layer_0_2__1);
NumDims.x_net_block5_block5_0_layer_layer_2_2__1 = NumDims.x_net_block5_block5_0_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_1_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1565, Vars.onnx__Conv_1566, Vars.ConvStride1199, Vars.ConvDilationFactor1200, Vars.ConvPadding1201, 1, NumDims.x_net_block5_block5_0_layer_layer_2_2__1, NumDims.onnx__Conv_1565);
Vars.x_net_block5_block5_1_layer_layer_0_2__1 = dlconv(Vars.x_net_block5_block5_0_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_1_layer_layer_2_2__1 = relu(Vars.x_net_block5_block5_1_layer_layer_0_2__1);
NumDims.x_net_block5_block5_1_layer_layer_2_2__1 = NumDims.x_net_block5_block5_1_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_2_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1568, Vars.onnx__Conv_1569, Vars.ConvStride1202, Vars.ConvDilationFactor1203, Vars.ConvPadding1204, 1, NumDims.x_net_block5_block5_1_layer_layer_2_2__1, NumDims.onnx__Conv_1568);
Vars.x_net_block5_block5_2_layer_layer_0_2__1 = dlconv(Vars.x_net_block5_block5_1_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_2_layer_layer_2_2__1 = relu(Vars.x_net_block5_block5_2_layer_layer_0_2__1);
NumDims.x_net_block5_block5_2_layer_layer_2_2__1 = NumDims.x_net_block5_block5_2_layer_layer_0_2__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_3_layer_layer_0_2__1] = prepareConvArgs(Vars.onnx__Conv_1571, Vars.onnx__Conv_1572, Vars.ConvStride1205, Vars.ConvDilationFactor1206, Vars.ConvPadding1207, 1, NumDims.x_net_block5_block5_2_layer_layer_2_2__1, NumDims.onnx__Conv_1571);
Vars.x_net_block5_block5_3_layer_layer_0_2__1 = dlconv(Vars.x_net_block5_block5_2_layer_layer_2_2__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_3_layer_layer_2_2__1 = relu(Vars.x_net_block5_block5_3_layer_layer_0_2__1);
NumDims.x_net_block5_block5_3_layer_layer_2_2__1 = NumDims.x_net_block5_block5_3_layer_layer_0_2__1;

% Shape:
[Vars.x_net_2_Shape_output_0, NumDims.x_net_2_Shape_output_0] = onnxShape(Vars.x_net_block3_block3_2_layer_layer_2_2__1, NumDims.x_net_block3_block3_2_layer_layer_2_2__1, 0, NumDims.x_net_block3_block3_2_layer_layer_2_2__1+1);

% Gather:
[Vars.x_net_2_Gather_output_0, NumDims.x_net_2_Gather_output_0] = onnxGather(Vars.x_net_2_Shape_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_net_2_Shape_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_net_2_Gather_1_output_0, NumDims.x_net_2_Gather_1_output_0] = onnxGather(Vars.x_net_2_Shape_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_net_2_Shape_output_0, NumDims.x_Constant_3_output_0);

% Unsqueeze:
[shape, NumDims.x_net_2_Unsqueeze_output_0] = prepareUnsqueezeArgs(Vars.x_net_2_Gather_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_2_Gather_output_0);
Vars.x_net_2_Unsqueeze_output_0 = reshape(Vars.x_net_2_Gather_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_net_2_Unsqueeze_1_output_0] = prepareUnsqueezeArgs(Vars.x_net_2_Gather_1_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_2_Gather_1_output_0);
Vars.x_net_2_Unsqueeze_1_output_0 = reshape(Vars.x_net_2_Gather_1_output_0, shape);

% Shape:
[Vars.x_net_2_Shape_2_output_0, NumDims.x_net_2_Shape_2_output_0] = onnxShape(Vars.x_net_block4_block4_2_layer_layer_2_2__1, NumDims.x_net_block4_block4_2_layer_layer_2_2__1, 0, NumDims.x_net_block4_block4_2_layer_layer_2_2__1+1);

% Slice:
[Indices, NumDims.x_net_2_Slice_output_0] = prepareSliceArgs(Vars.x_net_2_Shape_2_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_2_Shape_2_output_0);
Vars.x_net_2_Slice_output_0 = subsref(Vars.x_net_2_Shape_2_output_0, Indices);

% Concat:
[Vars.x_net_2_Concat_1_output_0, NumDims.x_net_2_Concat_1_output_0] = onnxConcat(0, {Vars.x_net_2_Slice_output_0, Vars.x_net_2_Unsqueeze_output_0, Vars.x_net_2_Unsqueeze_1_output_0}, [NumDims.x_net_2_Slice_output_0, NumDims.x_net_2_Unsqueeze_output_0, NumDims.x_net_2_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_2_Resize_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_2_Concat_1_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block4_block4_2_layer_layer_2_2__1);
if isempty(DLTScales)
    Vars.x_net_2_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_2__1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_2_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_2__1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Shape:
[Vars.x_net_2_Shape_5_output_0, NumDims.x_net_2_Shape_5_output_0] = onnxShape(Vars.x_net_block5_block5_3_layer_layer_2_2__1, NumDims.x_net_block5_block5_3_layer_layer_2_2__1, 0, NumDims.x_net_block5_block5_3_layer_layer_2_2__1+1);

% Slice:
[Indices, NumDims.x_net_2_Slice_1_output_0] = prepareSliceArgs(Vars.x_net_2_Shape_5_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_2_Shape_5_output_0);
Vars.x_net_2_Slice_1_output_0 = subsref(Vars.x_net_2_Shape_5_output_0, Indices);

% Concat:
[Vars.x_net_2_Concat_3_output_0, NumDims.x_net_2_Concat_3_output_0] = onnxConcat(0, {Vars.x_net_2_Slice_1_output_0, Vars.x_net_2_Unsqueeze_output_0, Vars.x_net_2_Unsqueeze_1_output_0}, [NumDims.x_net_2_Slice_1_output_0, NumDims.x_net_2_Unsqueeze_output_0, NumDims.x_net_2_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_2_Resize_1_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_2_Concat_3_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block5_block5_3_layer_layer_2_2__1);
if isempty(DLTScales)
    Vars.x_net_2_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_2__1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_2_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_2__1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Add:
Vars.x_net_2_Add_1_output_0 = Vars.x_net_block3_block3_2_layer_layer_2_2__1 + Vars.x_net_2_Resize_output_0;
NumDims.x_net_2_Add_1_output_0 = max(NumDims.x_net_block3_block3_2_layer_layer_2_2__1, NumDims.x_net_2_Resize_output_0);

% Add:
Vars.x_net_2_Add_2_output_0 = Vars.x_net_2_Add_1_output_0 + Vars.x_net_2_Resize_1_output_0;
NumDims.x_net_2_Add_2_output_0 = max(NumDims.x_net_2_Add_1_output_0, NumDims.x_net_2_Resize_1_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_0_lay_5] = prepareConvArgs(Vars.onnx__Conv_1574, Vars.onnx__Conv_1575, Vars.ConvStride1208, Vars.ConvDilationFactor1209, Vars.ConvPadding1210, 1, NumDims.x_net_2_Add_2_output_0, NumDims.onnx__Conv_1574);
Vars.x_net_block_fusion_block_fusion_0_lay_5 = dlconv(Vars.x_net_2_Add_2_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_0_lay_13 = relu(Vars.x_net_block_fusion_block_fusion_0_lay_5);
NumDims.x_net_block_fusion_block_fusion_0_lay_13 = NumDims.x_net_block_fusion_block_fusion_0_lay_5;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_1_lay_5] = prepareConvArgs(Vars.onnx__Conv_1577, Vars.onnx__Conv_1578, Vars.ConvStride1211, Vars.ConvDilationFactor1212, Vars.ConvPadding1213, 1, NumDims.x_net_block_fusion_block_fusion_0_lay_13, NumDims.onnx__Conv_1577);
Vars.x_net_block_fusion_block_fusion_1_lay_5 = dlconv(Vars.x_net_block_fusion_block_fusion_0_lay_13, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_1_lay_13 = relu(Vars.x_net_block_fusion_block_fusion_1_lay_5);
NumDims.x_net_block_fusion_block_fusion_1_lay_13 = NumDims.x_net_block_fusion_block_fusion_1_lay_5;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_2_2_Co_1] = prepareConvArgs(Vars.net_block_fusion_2_weight, Vars.net_block_fusion_2_bias, Vars.ConvStride1214, Vars.ConvDilationFactor1215, Vars.ConvPadding1216, 1, NumDims.x_net_block_fusion_block_fusion_1_lay_13, NumDims.net_block_fusion_2_weight);
Vars.x_net_block_fusion_block_fusion_2_2_Co_1 = dlconv(Vars.x_net_block_fusion_block_fusion_1_lay_13, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_0_lay_5] = prepareConvArgs(Vars.onnx__Conv_1580, Vars.onnx__Conv_1581, Vars.ConvStride1217, Vars.ConvDilationFactor1218, Vars.ConvPadding1219, 1, NumDims.x_net_block_fusion_block_fusion_2_2_Co_1, NumDims.onnx__Conv_1580);
Vars.x_net_heatmap_head_heatmap_head_0_lay_5 = dlconv(Vars.x_net_block_fusion_block_fusion_2_2_Co_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_0_lay_13 = relu(Vars.x_net_heatmap_head_heatmap_head_0_lay_5);
NumDims.x_net_heatmap_head_heatmap_head_0_lay_13 = NumDims.x_net_heatmap_head_heatmap_head_0_lay_5;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_1_lay_5] = prepareConvArgs(Vars.onnx__Conv_1583, Vars.onnx__Conv_1584, Vars.ConvStride1220, Vars.ConvDilationFactor1221, Vars.ConvPadding1222, 1, NumDims.x_net_heatmap_head_heatmap_head_0_lay_13, NumDims.onnx__Conv_1583);
Vars.x_net_heatmap_head_heatmap_head_1_lay_5 = dlconv(Vars.x_net_heatmap_head_heatmap_head_0_lay_13, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_1_lay_13 = relu(Vars.x_net_heatmap_head_heatmap_head_1_lay_5);
NumDims.x_net_heatmap_head_heatmap_head_1_lay_13 = NumDims.x_net_heatmap_head_heatmap_head_1_lay_5;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_2_2_Co_1] = prepareConvArgs(Vars.net_heatmap_head_2_weight, Vars.net_heatmap_head_2_bias, Vars.ConvStride1223, Vars.ConvDilationFactor1224, Vars.ConvPadding1225, 1, NumDims.x_net_heatmap_head_heatmap_head_1_lay_13, NumDims.net_heatmap_head_2_weight);
Vars.x_net_heatmap_head_heatmap_head_2_2_Co_1 = dlconv(Vars.x_net_heatmap_head_heatmap_head_1_lay_13, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Sigmoid:
Vars.x_net_heatmap_head_heatmap_head_3_2_Si_1 = sigmoid(Vars.x_net_heatmap_head_heatmap_head_2_2_Co_1);
NumDims.x_net_heatmap_head_heatmap_head_3_2_Si_1 = NumDims.x_net_heatmap_head_heatmap_head_2_2_Co_1;

% Shape:
[Vars.x_Shape_27_output_0, NumDims.x_Shape_27_output_0] = onnxShape(Vars.x_net_block_fusion_block_fusion_2_2_Co_1, NumDims.x_net_block_fusion_block_fusion_2_2_Co_1, 0, NumDims.x_net_block_fusion_block_fusion_2_2_Co_1+1);

% Gather:
[Vars.x_Gather_18_output_0, NumDims.x_Gather_18_output_0] = onnxGather(Vars.x_Shape_27_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Shape_27_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_20_output_0, NumDims.x_Gather_20_output_0] = onnxGather(Vars.x_Shape_27_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_27_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_21_output_0, NumDims.x_Gather_21_output_0] = onnxGather(Vars.x_Shape_27_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_27_output_0, NumDims.x_Constant_3_output_0);

% Range:
Vars.x_Range_4_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_20_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_4_output_0 = 1;

% Range:
Vars.x_Range_5_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_21_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_5_output_0 = 1;

% Shape:
[Vars.x_Shape_31_output_0, NumDims.x_Shape_31_output_0] = onnxShape(Vars.x_Range_4_output_0, NumDims.x_Range_4_output_0, 0, NumDims.x_Range_4_output_0+1);

% Shape:
[Vars.x_Shape_32_output_0, NumDims.x_Shape_32_output_0] = onnxShape(Vars.x_Range_5_output_0, NumDims.x_Range_5_output_0, 0, NumDims.x_Range_5_output_0+1);

% Concat:
[Vars.x_Concat_25_output_0, NumDims.x_Concat_25_output_0] = onnxConcat(0, {Vars.x_Shape_31_output_0, Vars.x_Shape_32_output_0}, [NumDims.x_Shape_31_output_0, NumDims.x_Shape_32_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_18_output_0] = prepareReshapeArgs(Vars.x_Range_4_output_0, Vars.x_v_1932, NumDims.x_Range_4_output_0, 0);
Vars.x_Reshape_18_output_0 = reshape(Vars.x_Range_4_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_10_output_0] = prepareExpandArgs(Vars.x_Concat_25_output_0);
Vars.x_Expand_10_output_0 = Vars.x_Reshape_18_output_0 + zeros(shape);

% Reshape:
[shape, NumDims.x_Reshape_19_output_0] = prepareReshapeArgs(Vars.x_Range_5_output_0, Vars.x_v_1934, NumDims.x_Range_5_output_0, 0);
Vars.x_Reshape_19_output_0 = reshape(Vars.x_Range_5_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_11_output_0] = prepareExpandArgs(Vars.x_Concat_25_output_0);
Vars.x_Expand_11_output_0 = Vars.x_Reshape_19_output_0 + zeros(shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_24_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_11_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_11_output_0);
Vars.x_Unsqueeze_24_output_0 = reshape(Vars.x_Expand_11_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_25_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_10_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_10_output_0);
Vars.x_Unsqueeze_25_output_0 = reshape(Vars.x_Expand_10_output_0, shape);

% Concat:
[Vars.x_Concat_28_output_0, NumDims.x_Concat_28_output_0] = onnxConcat(-1, {Vars.x_Unsqueeze_24_output_0, Vars.x_Unsqueeze_25_output_0}, [NumDims.x_Unsqueeze_24_output_0, NumDims.x_Unsqueeze_25_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_20_output_0] = prepareReshapeArgs(Vars.x_Concat_28_output_0, Vars.x_Constant_26_output_0, NumDims.x_Concat_28_output_0, 0);
Vars.x_Reshape_20_output_0 = reshape(Vars.x_Concat_28_output_0, shape{:});

% Mul:
Vars.x_Mul_18_output_0 = Vars.x_Reshape_20_output_0 .* Vars.x_Constant_27_output_0;
NumDims.x_Mul_18_output_0 = max(NumDims.x_Reshape_20_output_0, NumDims.x_Constant_27_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_26_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_18_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_18_output_0);
Vars.x_Unsqueeze_26_output_0 = reshape(Vars.x_Gather_18_output_0, shape);

% Concat:
[Vars.x_Concat_29_output_0, NumDims.x_Concat_29_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_26_output_0, Vars.x_Constant_29_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_26_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Constant_29_output_0]);

% Equal:
Vars.x_Equal_6_output_0 = Vars.x_Concat_29_output_0 == Vars.x_Mul_3_output_0;
NumDims.x_Equal_6_output_0 = max(NumDims.x_Concat_29_output_0, NumDims.x_Mul_3_output_0);

% Where:
[Vars.x_Where_6_output_0, NumDims.x_Where_6_output_0] = onnxWhere(Vars.x_Equal_6_output_0, Vars.x_ConstantOfShape_output_0, Vars.x_Concat_29_output_0, NumDims.x_Equal_6_output_0, NumDims.x_ConstantOfShape_output_0, NumDims.x_Concat_29_output_0);

% Expand:
[shape, NumDims.x_Expand_12_output_0] = prepareExpandArgs(Vars.x_Where_6_output_0);
Vars.x_Expand_12_output_0 = Vars.x_Mul_18_output_0 + zeros(shape);

% Transpose:
[perm, NumDims.x_Transpose_4_output_0] = prepareTransposeArgs(Vars.TransposePerm1226, NumDims.x_net_block_fusion_block_fusion_2_2_Co_1);
if ~isempty(perm)
    Vars.x_Transpose_4_output_0 = permute(Vars.x_net_block_fusion_block_fusion_2_2_Co_1, perm);
end

% Concat:
[Vars.x_Concat_30_output_0, NumDims.x_Concat_30_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_26_output_0, Vars.x_Constant_29_output_0, Vars.x_Unsqueeze_6_output_0}, [NumDims.x_Unsqueeze_26_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Unsqueeze_6_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_22_output_0] = prepareReshapeArgs(Vars.x_Transpose_4_output_0, Vars.x_Concat_30_output_0, NumDims.x_Transpose_4_output_0, 0);
Vars.x_Reshape_22_output_0 = reshape(Vars.x_Transpose_4_output_0, shape{:});

% Transpose:
[perm, NumDims.x_Transpose_5_output_0] = prepareTransposeArgs(Vars.TransposePerm1227, NumDims.x_net_heatmap_head_heatmap_head_3_2_Si_1);
if ~isempty(perm)
    Vars.x_Transpose_5_output_0 = permute(Vars.x_net_heatmap_head_heatmap_head_3_2_Si_1, perm);
end

% Concat:
[Vars.x_Concat_31_output_0, NumDims.x_Concat_31_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_26_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_26_output_0, NumDims.x_Constant_29_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_23_output_0] = prepareReshapeArgs(Vars.x_Transpose_5_output_0, Vars.x_Concat_31_output_0, NumDims.x_Transpose_5_output_0, 0);
Vars.x_Reshape_23_output_0 = reshape(Vars.x_Transpose_5_output_0, shape{:});

% TopK:
[Vars.x_TopK_2_output_0, Vars.x_TopK_2_output_1, NumDims.x_TopK_2_output_0, NumDims.x_TopK_2_output_1] = onnxTopK11(Vars.x_Reshape_23_output_0, Vars.x_Constant_35_output_0, -1, 1, 1, NumDims.x_Reshape_23_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_30_output_0] = prepareUnsqueezeArgs(Vars.x_TopK_2_output_1, Vars.x_net_Constant_4_output_0, NumDims.x_TopK_2_output_1);
Vars.x_Unsqueeze_30_output_0 = reshape(Vars.x_TopK_2_output_1, shape);

% Expand:
[shape, NumDims.x_Expand_13_output_0] = prepareExpandArgs(Vars.x_Where_1_output_0);
Vars.x_Expand_13_output_0 = Vars.x_Unsqueeze_30_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_4_output_0, NumDims.x_GatherElements_4_output_0] = onnxGatherElements(Vars.x_Reshape_22_output_0, Vars.x_Expand_13_output_0, 1, NumDims.x_Reshape_22_output_0, NumDims.x_Expand_13_output_0);

% Expand:
[shape, NumDims.x_Expand_14_output_0] = prepareExpandArgs(Vars.x_Where_2_output_0);
Vars.x_Expand_14_output_0 = Vars.x_Unsqueeze_30_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_5_output_0, NumDims.x_GatherElements_5_output_0] = onnxGatherElements(Vars.x_Expand_12_output_0, Vars.x_Expand_14_output_0, 1, NumDims.x_Expand_12_output_0, NumDims.x_Expand_14_output_0);

% Cast:
if islogical(Vars.x_GatherElements_5_output_0)
    Vars.x_GatherElements_5_output_0 = single(Vars.x_GatherElements_5_output_0);
end
Vars.x_Cast_26_output_0 = single(Vars.x_GatherElements_5_output_0);
NumDims.x_Cast_26_output_0 = NumDims.x_GatherElements_5_output_0;

% Shape:
[Vars.x_Shape_34_output_0, NumDims.x_Shape_34_output_0] = onnxShape(Vars.x_Resize_5_output_0, NumDims.x_Resize_5_output_0, 0, NumDims.x_Resize_5_output_0+1);

% Gather:
[Vars.x_Gather_22_output_0, NumDims.x_Gather_22_output_0] = onnxGather(Vars.x_Shape_34_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_34_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_23_output_0, NumDims.x_Gather_23_output_0] = onnxGather(Vars.x_Shape_34_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_34_output_0, NumDims.x_Constant_3_output_0);

% Div:
Vars.x_Div_8_output_0 = fix(Vars.x_Gather_22_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_8_output_0 = max(NumDims.x_Gather_22_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_23_output_0 = Vars.x_Div_8_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_23_output_0 = max(NumDims.x_Div_8_output_0, NumDims.x_Constant_4_output_0);

% Div:
Vars.x_Div_9_output_0 = fix(Vars.x_Gather_23_output_0 ./ Vars.x_Constant_4_output_0);
NumDims.x_Div_9_output_0 = max(NumDims.x_Gather_23_output_0, NumDims.x_Constant_4_output_0);

% Mul:
Vars.x_Mul_24_output_0 = Vars.x_Div_9_output_0 .* Vars.x_Constant_4_output_0;
NumDims.x_Mul_24_output_0 = max(NumDims.x_Div_9_output_0, NumDims.x_Constant_4_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_31_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_23_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_23_output_0);
Vars.x_Unsqueeze_31_output_0 = reshape(Vars.x_Mul_23_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_32_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_24_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Mul_24_output_0);
Vars.x_Unsqueeze_32_output_0 = reshape(Vars.x_Mul_24_output_0, shape);

% Concat:
[Vars.x_Concat_33_output_0, NumDims.x_Concat_33_output_0] = onnxConcat(0, {Vars.x_v_1924, Vars.x_Unsqueeze_31_output_0, Vars.x_Unsqueeze_32_output_0}, [NumDims.x_v_1924, NumDims.x_Unsqueeze_31_output_0, NumDims.x_Unsqueeze_32_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_Resize_7_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_Concat_33_output_0, "half_pixel", "linear", "floor", NumDims.x_Resize_5_output_0);
if isempty(DLTScales)
    Vars.x_Resize_7_output_0 = dlresize(Vars.x_Resize_5_output_0, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_Resize_7_output_0 = dlresize(Vars.x_Resize_5_output_0, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% ReduceMean:
dims = prepareReduceArgs(Vars.ReduceMeanAxes1228, NumDims.x_Resize_7_output_0);
Vars.x_net_3_ReduceMean_output_0 = mean(Vars.x_Resize_7_output_0, dims);
NumDims.x_net_3_ReduceMean_output_0 = NumDims.x_Resize_7_output_0;

% InstanceNormalization:
if NumDims.x_net_3_ReduceMean_output_0 > 1
    Vars.x_net_norm_3_InstanceNormalization_outpu = instancenorm(Vars.x_net_3_ReduceMean_output_0, Vars.x_net_norm_Constant_1_output_0, Vars.x_net_norm_Constant_output_0, 'Epsilon', 0.000010, 'DataFormat', [repmat('S',[1 NumDims.x_net_3_ReduceMean_output_0-2]),'CB']);
end
NumDims.x_net_norm_3_InstanceNormalization_outpu = NumDims.x_net_3_ReduceMean_output_0;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_0_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1526, Vars.onnx__Conv_1527, Vars.ConvStride1229, Vars.ConvDilationFactor1230, Vars.ConvPadding1231, 1, NumDims.x_net_norm_3_InstanceNormalization_outpu, NumDims.onnx__Conv_1526);
Vars.x_net_block1_block1_0_layer_layer_0_3__1 = dlconv(Vars.x_net_norm_3_InstanceNormalization_outpu, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_0_layer_layer_2_3__1 = relu(Vars.x_net_block1_block1_0_layer_layer_0_3__1);
NumDims.x_net_block1_block1_0_layer_layer_2_3__1 = NumDims.x_net_block1_block1_0_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_1_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1529, Vars.onnx__Conv_1530, Vars.ConvStride1232, Vars.ConvDilationFactor1233, Vars.ConvPadding1234, 1, NumDims.x_net_block1_block1_0_layer_layer_2_3__1, NumDims.onnx__Conv_1529);
Vars.x_net_block1_block1_1_layer_layer_0_3__1 = dlconv(Vars.x_net_block1_block1_0_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_1_layer_layer_2_3__1 = relu(Vars.x_net_block1_block1_1_layer_layer_0_3__1);
NumDims.x_net_block1_block1_1_layer_layer_2_3__1 = NumDims.x_net_block1_block1_1_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_2_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1532, Vars.onnx__Conv_1533, Vars.ConvStride1235, Vars.ConvDilationFactor1236, Vars.ConvPadding1237, 1, NumDims.x_net_block1_block1_1_layer_layer_2_3__1, NumDims.onnx__Conv_1532);
Vars.x_net_block1_block1_2_layer_layer_0_3__1 = dlconv(Vars.x_net_block1_block1_1_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_2_layer_layer_2_3__1 = relu(Vars.x_net_block1_block1_2_layer_layer_0_3__1);
NumDims.x_net_block1_block1_2_layer_layer_2_3__1 = NumDims.x_net_block1_block1_2_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block1_block1_3_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1535, Vars.onnx__Conv_1536, Vars.ConvStride1238, Vars.ConvDilationFactor1239, Vars.ConvPadding1240, 1, NumDims.x_net_block1_block1_2_layer_layer_2_3__1, NumDims.onnx__Conv_1535);
Vars.x_net_block1_block1_3_layer_layer_0_3__1 = dlconv(Vars.x_net_block1_block1_2_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block1_block1_3_layer_layer_2_3__1 = relu(Vars.x_net_block1_block1_3_layer_layer_0_3__1);
NumDims.x_net_block1_block1_3_layer_layer_2_3__1 = NumDims.x_net_block1_block1_3_layer_layer_0_3__1;

% AveragePool:
[poolSize, stride, padding, paddingValue, dataFormat, NumDims.x_net_skip1_skip1_0_3_AveragePool_output] = prepareAveragePoolArgs(Vars.AveragePoolPoolSize1241, Vars.AveragePoolStride1242, Vars.AveragePoolPadding1243, 1, NumDims.x_net_norm_3_InstanceNormalization_outpu);
Vars.x_net_skip1_skip1_0_3_AveragePool_output = avgpool(Vars.x_net_norm_3_InstanceNormalization_outpu, poolSize, 'Stride', stride, 'Padding', padding, 'PaddingValue', paddingValue, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_skip1_skip1_1_3_Conv_output_0] = prepareConvArgs(Vars.net_skip1_1_weight, Vars.net_skip1_1_bias, Vars.ConvStride1244, Vars.ConvDilationFactor1245, Vars.ConvPadding1246, 1, NumDims.x_net_skip1_skip1_0_3_AveragePool_output, NumDims.net_skip1_1_weight);
Vars.x_net_skip1_skip1_1_3_Conv_output_0 = dlconv(Vars.x_net_skip1_skip1_0_3_AveragePool_output, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Add:
Vars.x_net_3_Add_output_0 = Vars.x_net_block1_block1_3_layer_layer_2_3__1 + Vars.x_net_skip1_skip1_1_3_Conv_output_0;
NumDims.x_net_3_Add_output_0 = max(NumDims.x_net_block1_block1_3_layer_layer_2_3__1, NumDims.x_net_skip1_skip1_1_3_Conv_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_0_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1538, Vars.onnx__Conv_1539, Vars.ConvStride1247, Vars.ConvDilationFactor1248, Vars.ConvPadding1249, 1, NumDims.x_net_3_Add_output_0, NumDims.onnx__Conv_1538);
Vars.x_net_block2_block2_0_layer_layer_0_3__1 = dlconv(Vars.x_net_3_Add_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_0_layer_layer_2_3__1 = relu(Vars.x_net_block2_block2_0_layer_layer_0_3__1);
NumDims.x_net_block2_block2_0_layer_layer_2_3__1 = NumDims.x_net_block2_block2_0_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block2_block2_1_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1541, Vars.onnx__Conv_1542, Vars.ConvStride1250, Vars.ConvDilationFactor1251, Vars.ConvPadding1252, 1, NumDims.x_net_block2_block2_0_layer_layer_2_3__1, NumDims.onnx__Conv_1541);
Vars.x_net_block2_block2_1_layer_layer_0_3__1 = dlconv(Vars.x_net_block2_block2_0_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block2_block2_1_layer_layer_2_3__1 = relu(Vars.x_net_block2_block2_1_layer_layer_0_3__1);
NumDims.x_net_block2_block2_1_layer_layer_2_3__1 = NumDims.x_net_block2_block2_1_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_0_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1544, Vars.onnx__Conv_1545, Vars.ConvStride1253, Vars.ConvDilationFactor1254, Vars.ConvPadding1255, 1, NumDims.x_net_block2_block2_1_layer_layer_2_3__1, NumDims.onnx__Conv_1544);
Vars.x_net_block3_block3_0_layer_layer_0_3__1 = dlconv(Vars.x_net_block2_block2_1_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_0_layer_layer_2_3__1 = relu(Vars.x_net_block3_block3_0_layer_layer_0_3__1);
NumDims.x_net_block3_block3_0_layer_layer_2_3__1 = NumDims.x_net_block3_block3_0_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_1_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1547, Vars.onnx__Conv_1548, Vars.ConvStride1256, Vars.ConvDilationFactor1257, Vars.ConvPadding1258, 1, NumDims.x_net_block3_block3_0_layer_layer_2_3__1, NumDims.onnx__Conv_1547);
Vars.x_net_block3_block3_1_layer_layer_0_3__1 = dlconv(Vars.x_net_block3_block3_0_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_1_layer_layer_2_3__1 = relu(Vars.x_net_block3_block3_1_layer_layer_0_3__1);
NumDims.x_net_block3_block3_1_layer_layer_2_3__1 = NumDims.x_net_block3_block3_1_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block3_block3_2_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1550, Vars.onnx__Conv_1551, Vars.ConvStride1259, Vars.ConvDilationFactor1260, Vars.ConvPadding1261, 1, NumDims.x_net_block3_block3_1_layer_layer_2_3__1, NumDims.onnx__Conv_1550);
Vars.x_net_block3_block3_2_layer_layer_0_3__1 = dlconv(Vars.x_net_block3_block3_1_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block3_block3_2_layer_layer_2_3__1 = relu(Vars.x_net_block3_block3_2_layer_layer_0_3__1);
NumDims.x_net_block3_block3_2_layer_layer_2_3__1 = NumDims.x_net_block3_block3_2_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_0_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1553, Vars.onnx__Conv_1554, Vars.ConvStride1262, Vars.ConvDilationFactor1263, Vars.ConvPadding1264, 1, NumDims.x_net_block3_block3_2_layer_layer_2_3__1, NumDims.onnx__Conv_1553);
Vars.x_net_block4_block4_0_layer_layer_0_3__1 = dlconv(Vars.x_net_block3_block3_2_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_0_layer_layer_2_3__1 = relu(Vars.x_net_block4_block4_0_layer_layer_0_3__1);
NumDims.x_net_block4_block4_0_layer_layer_2_3__1 = NumDims.x_net_block4_block4_0_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_1_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1556, Vars.onnx__Conv_1557, Vars.ConvStride1265, Vars.ConvDilationFactor1266, Vars.ConvPadding1267, 1, NumDims.x_net_block4_block4_0_layer_layer_2_3__1, NumDims.onnx__Conv_1556);
Vars.x_net_block4_block4_1_layer_layer_0_3__1 = dlconv(Vars.x_net_block4_block4_0_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_1_layer_layer_2_3__1 = relu(Vars.x_net_block4_block4_1_layer_layer_0_3__1);
NumDims.x_net_block4_block4_1_layer_layer_2_3__1 = NumDims.x_net_block4_block4_1_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block4_block4_2_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1559, Vars.onnx__Conv_1560, Vars.ConvStride1268, Vars.ConvDilationFactor1269, Vars.ConvPadding1270, 1, NumDims.x_net_block4_block4_1_layer_layer_2_3__1, NumDims.onnx__Conv_1559);
Vars.x_net_block4_block4_2_layer_layer_0_3__1 = dlconv(Vars.x_net_block4_block4_1_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block4_block4_2_layer_layer_2_3__1 = relu(Vars.x_net_block4_block4_2_layer_layer_0_3__1);
NumDims.x_net_block4_block4_2_layer_layer_2_3__1 = NumDims.x_net_block4_block4_2_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_0_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1562, Vars.onnx__Conv_1563, Vars.ConvStride1271, Vars.ConvDilationFactor1272, Vars.ConvPadding1273, 1, NumDims.x_net_block4_block4_2_layer_layer_2_3__1, NumDims.onnx__Conv_1562);
Vars.x_net_block5_block5_0_layer_layer_0_3__1 = dlconv(Vars.x_net_block4_block4_2_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_0_layer_layer_2_3__1 = relu(Vars.x_net_block5_block5_0_layer_layer_0_3__1);
NumDims.x_net_block5_block5_0_layer_layer_2_3__1 = NumDims.x_net_block5_block5_0_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_1_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1565, Vars.onnx__Conv_1566, Vars.ConvStride1274, Vars.ConvDilationFactor1275, Vars.ConvPadding1276, 1, NumDims.x_net_block5_block5_0_layer_layer_2_3__1, NumDims.onnx__Conv_1565);
Vars.x_net_block5_block5_1_layer_layer_0_3__1 = dlconv(Vars.x_net_block5_block5_0_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_1_layer_layer_2_3__1 = relu(Vars.x_net_block5_block5_1_layer_layer_0_3__1);
NumDims.x_net_block5_block5_1_layer_layer_2_3__1 = NumDims.x_net_block5_block5_1_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_2_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1568, Vars.onnx__Conv_1569, Vars.ConvStride1277, Vars.ConvDilationFactor1278, Vars.ConvPadding1279, 1, NumDims.x_net_block5_block5_1_layer_layer_2_3__1, NumDims.onnx__Conv_1568);
Vars.x_net_block5_block5_2_layer_layer_0_3__1 = dlconv(Vars.x_net_block5_block5_1_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_2_layer_layer_2_3__1 = relu(Vars.x_net_block5_block5_2_layer_layer_0_3__1);
NumDims.x_net_block5_block5_2_layer_layer_2_3__1 = NumDims.x_net_block5_block5_2_layer_layer_0_3__1;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block5_block5_3_layer_layer_0_3__1] = prepareConvArgs(Vars.onnx__Conv_1571, Vars.onnx__Conv_1572, Vars.ConvStride1280, Vars.ConvDilationFactor1281, Vars.ConvPadding1282, 1, NumDims.x_net_block5_block5_2_layer_layer_2_3__1, NumDims.onnx__Conv_1571);
Vars.x_net_block5_block5_3_layer_layer_0_3__1 = dlconv(Vars.x_net_block5_block5_2_layer_layer_2_3__1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block5_block5_3_layer_layer_2_3__1 = relu(Vars.x_net_block5_block5_3_layer_layer_0_3__1);
NumDims.x_net_block5_block5_3_layer_layer_2_3__1 = NumDims.x_net_block5_block5_3_layer_layer_0_3__1;

% Shape:
[Vars.x_net_3_Shape_output_0, NumDims.x_net_3_Shape_output_0] = onnxShape(Vars.x_net_block3_block3_2_layer_layer_2_3__1, NumDims.x_net_block3_block3_2_layer_layer_2_3__1, 0, NumDims.x_net_block3_block3_2_layer_layer_2_3__1+1);

% Gather:
[Vars.x_net_3_Gather_output_0, NumDims.x_net_3_Gather_output_0] = onnxGather(Vars.x_net_3_Shape_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_net_3_Shape_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_net_3_Gather_1_output_0, NumDims.x_net_3_Gather_1_output_0] = onnxGather(Vars.x_net_3_Shape_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_net_3_Shape_output_0, NumDims.x_Constant_3_output_0);

% Unsqueeze:
[shape, NumDims.x_net_3_Unsqueeze_output_0] = prepareUnsqueezeArgs(Vars.x_net_3_Gather_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_3_Gather_output_0);
Vars.x_net_3_Unsqueeze_output_0 = reshape(Vars.x_net_3_Gather_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_net_3_Unsqueeze_1_output_0] = prepareUnsqueezeArgs(Vars.x_net_3_Gather_1_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_net_3_Gather_1_output_0);
Vars.x_net_3_Unsqueeze_1_output_0 = reshape(Vars.x_net_3_Gather_1_output_0, shape);

% Shape:
[Vars.x_net_3_Shape_2_output_0, NumDims.x_net_3_Shape_2_output_0] = onnxShape(Vars.x_net_block4_block4_2_layer_layer_2_3__1, NumDims.x_net_block4_block4_2_layer_layer_2_3__1, 0, NumDims.x_net_block4_block4_2_layer_layer_2_3__1+1);

% Slice:
[Indices, NumDims.x_net_3_Slice_output_0] = prepareSliceArgs(Vars.x_net_3_Shape_2_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_3_Shape_2_output_0);
Vars.x_net_3_Slice_output_0 = subsref(Vars.x_net_3_Shape_2_output_0, Indices);

% Concat:
[Vars.x_net_3_Concat_1_output_0, NumDims.x_net_3_Concat_1_output_0] = onnxConcat(0, {Vars.x_net_3_Slice_output_0, Vars.x_net_3_Unsqueeze_output_0, Vars.x_net_3_Unsqueeze_1_output_0}, [NumDims.x_net_3_Slice_output_0, NumDims.x_net_3_Unsqueeze_output_0, NumDims.x_net_3_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_3_Resize_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_3_Concat_1_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block4_block4_2_layer_layer_2_3__1);
if isempty(DLTScales)
    Vars.x_net_3_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_3__1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_3_Resize_output_0 = dlresize(Vars.x_net_block4_block4_2_layer_layer_2_3__1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Shape:
[Vars.x_net_3_Shape_5_output_0, NumDims.x_net_3_Shape_5_output_0] = onnxShape(Vars.x_net_block5_block5_3_layer_layer_2_3__1, NumDims.x_net_block5_block5_3_layer_layer_2_3__1, 0, NumDims.x_net_block5_block5_3_layer_layer_2_3__1+1);

% Slice:
[Indices, NumDims.x_net_3_Slice_1_output_0] = prepareSliceArgs(Vars.x_net_3_Shape_5_output_0, Vars.onnx__Unsqueeze_154, Vars.x_net_Constant_4_output_0, Vars.onnx__Unsqueeze_154, '', NumDims.x_net_3_Shape_5_output_0);
Vars.x_net_3_Slice_1_output_0 = subsref(Vars.x_net_3_Shape_5_output_0, Indices);

% Concat:
[Vars.x_net_3_Concat_3_output_0, NumDims.x_net_3_Concat_3_output_0] = onnxConcat(0, {Vars.x_net_3_Slice_1_output_0, Vars.x_net_3_Unsqueeze_output_0, Vars.x_net_3_Unsqueeze_1_output_0}, [NumDims.x_net_3_Slice_1_output_0, NumDims.x_net_3_Unsqueeze_output_0, NumDims.x_net_3_Unsqueeze_1_output_0]);

% Resize:
[DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, NumDims.x_net_3_Resize_1_output_0] = prepareResize11Args(dlarray([]), dlarray([]), Vars.x_net_3_Concat_3_output_0, "half_pixel", "linear", "floor", NumDims.x_net_block5_block5_3_layer_layer_2_3__1);
if isempty(DLTScales)
    Vars.x_net_3_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_3__1, 'OutputSize', DLTSizes, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
else
    Vars.x_net_3_Resize_1_output_0 = dlresize(Vars.x_net_block5_block5_3_layer_layer_2_3__1, 'Scale', DLTScales, 'DataFormat', dataFormat, 'Method', Method, 'GeometricTransformMode', GeometricTransformMode, 'NearestRoundingMode', NearestRoundingMode);
end

% Add:
Vars.x_net_3_Add_1_output_0 = Vars.x_net_block3_block3_2_layer_layer_2_3__1 + Vars.x_net_3_Resize_output_0;
NumDims.x_net_3_Add_1_output_0 = max(NumDims.x_net_block3_block3_2_layer_layer_2_3__1, NumDims.x_net_3_Resize_output_0);

% Add:
Vars.x_net_3_Add_2_output_0 = Vars.x_net_3_Add_1_output_0 + Vars.x_net_3_Resize_1_output_0;
NumDims.x_net_3_Add_2_output_0 = max(NumDims.x_net_3_Add_1_output_0, NumDims.x_net_3_Resize_1_output_0);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_0_lay_7] = prepareConvArgs(Vars.onnx__Conv_1574, Vars.onnx__Conv_1575, Vars.ConvStride1283, Vars.ConvDilationFactor1284, Vars.ConvPadding1285, 1, NumDims.x_net_3_Add_2_output_0, NumDims.onnx__Conv_1574);
Vars.x_net_block_fusion_block_fusion_0_lay_7 = dlconv(Vars.x_net_3_Add_2_output_0, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_0_lay_15 = relu(Vars.x_net_block_fusion_block_fusion_0_lay_7);
NumDims.x_net_block_fusion_block_fusion_0_lay_15 = NumDims.x_net_block_fusion_block_fusion_0_lay_7;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_1_lay_7] = prepareConvArgs(Vars.onnx__Conv_1577, Vars.onnx__Conv_1578, Vars.ConvStride1286, Vars.ConvDilationFactor1287, Vars.ConvPadding1288, 1, NumDims.x_net_block_fusion_block_fusion_0_lay_15, NumDims.onnx__Conv_1577);
Vars.x_net_block_fusion_block_fusion_1_lay_7 = dlconv(Vars.x_net_block_fusion_block_fusion_0_lay_15, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_block_fusion_block_fusion_1_lay_15 = relu(Vars.x_net_block_fusion_block_fusion_1_lay_7);
NumDims.x_net_block_fusion_block_fusion_1_lay_15 = NumDims.x_net_block_fusion_block_fusion_1_lay_7;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_block_fusion_block_fusion_2_3_Co_1] = prepareConvArgs(Vars.net_block_fusion_2_weight, Vars.net_block_fusion_2_bias, Vars.ConvStride1289, Vars.ConvDilationFactor1290, Vars.ConvPadding1291, 1, NumDims.x_net_block_fusion_block_fusion_1_lay_15, NumDims.net_block_fusion_2_weight);
Vars.x_net_block_fusion_block_fusion_2_3_Co_1 = dlconv(Vars.x_net_block_fusion_block_fusion_1_lay_15, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_0_lay_7] = prepareConvArgs(Vars.onnx__Conv_1580, Vars.onnx__Conv_1581, Vars.ConvStride1292, Vars.ConvDilationFactor1293, Vars.ConvPadding1294, 1, NumDims.x_net_block_fusion_block_fusion_2_3_Co_1, NumDims.onnx__Conv_1580);
Vars.x_net_heatmap_head_heatmap_head_0_lay_7 = dlconv(Vars.x_net_block_fusion_block_fusion_2_3_Co_1, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_0_lay_15 = relu(Vars.x_net_heatmap_head_heatmap_head_0_lay_7);
NumDims.x_net_heatmap_head_heatmap_head_0_lay_15 = NumDims.x_net_heatmap_head_heatmap_head_0_lay_7;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_1_lay_7] = prepareConvArgs(Vars.onnx__Conv_1583, Vars.onnx__Conv_1584, Vars.ConvStride1295, Vars.ConvDilationFactor1296, Vars.ConvPadding1297, 1, NumDims.x_net_heatmap_head_heatmap_head_0_lay_15, NumDims.onnx__Conv_1583);
Vars.x_net_heatmap_head_heatmap_head_1_lay_7 = dlconv(Vars.x_net_heatmap_head_heatmap_head_0_lay_15, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Relu:
Vars.x_net_heatmap_head_heatmap_head_1_lay_15 = relu(Vars.x_net_heatmap_head_heatmap_head_1_lay_7);
NumDims.x_net_heatmap_head_heatmap_head_1_lay_15 = NumDims.x_net_heatmap_head_heatmap_head_1_lay_7;

% Conv:
[weights, bias, stride, dilationFactor, padding, dataFormat, NumDims.x_net_heatmap_head_heatmap_head_2_3_Co_1] = prepareConvArgs(Vars.net_heatmap_head_2_weight, Vars.net_heatmap_head_2_bias, Vars.ConvStride1298, Vars.ConvDilationFactor1299, Vars.ConvPadding1300, 1, NumDims.x_net_heatmap_head_heatmap_head_1_lay_15, NumDims.net_heatmap_head_2_weight);
Vars.x_net_heatmap_head_heatmap_head_2_3_Co_1 = dlconv(Vars.x_net_heatmap_head_heatmap_head_1_lay_15, weights, bias, 'Stride', stride, 'DilationFactor', dilationFactor, 'Padding', padding, 'DataFormat', dataFormat);

% Sigmoid:
Vars.x_net_heatmap_head_heatmap_head_3_3_Si_1 = sigmoid(Vars.x_net_heatmap_head_heatmap_head_2_3_Co_1);
NumDims.x_net_heatmap_head_heatmap_head_3_3_Si_1 = NumDims.x_net_heatmap_head_heatmap_head_2_3_Co_1;

% Shape:
[Vars.x_Shape_37_output_0, NumDims.x_Shape_37_output_0] = onnxShape(Vars.x_net_block_fusion_block_fusion_2_3_Co_1, NumDims.x_net_block_fusion_block_fusion_2_3_Co_1, 0, NumDims.x_net_block_fusion_block_fusion_2_3_Co_1+1);

% Gather:
[Vars.x_Gather_24_output_0, NumDims.x_Gather_24_output_0] = onnxGather(Vars.x_Shape_37_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Shape_37_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_26_output_0, NumDims.x_Gather_26_output_0] = onnxGather(Vars.x_Shape_37_output_0, Vars.x_Constant_2_output_0, 0, NumDims.x_Shape_37_output_0, NumDims.x_Constant_2_output_0);

% Gather:
[Vars.x_Gather_27_output_0, NumDims.x_Gather_27_output_0] = onnxGather(Vars.x_Shape_37_output_0, Vars.x_Constant_3_output_0, 0, NumDims.x_Shape_37_output_0, NumDims.x_Constant_3_output_0);

% Range:
Vars.x_Range_6_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_26_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_6_output_0 = 1;

% Range:
Vars.x_Range_7_output_0 = dlarray(Vars.x_Constant_11_output_0:Vars.x_Constant_17_output_0:Vars.x_Gather_27_output_0-sign(Vars.x_Constant_17_output_0))';
NumDims.x_Range_7_output_0 = 1;

% Shape:
[Vars.x_Shape_41_output_0, NumDims.x_Shape_41_output_0] = onnxShape(Vars.x_Range_6_output_0, NumDims.x_Range_6_output_0, 0, NumDims.x_Range_6_output_0+1);

% Shape:
[Vars.x_Shape_42_output_0, NumDims.x_Shape_42_output_0] = onnxShape(Vars.x_Range_7_output_0, NumDims.x_Range_7_output_0, 0, NumDims.x_Range_7_output_0+1);

% Concat:
[Vars.x_Concat_34_output_0, NumDims.x_Concat_34_output_0] = onnxConcat(0, {Vars.x_Shape_41_output_0, Vars.x_Shape_42_output_0}, [NumDims.x_Shape_41_output_0, NumDims.x_Shape_42_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_26_output_0] = prepareReshapeArgs(Vars.x_Range_6_output_0, Vars.x_v_1932, NumDims.x_Range_6_output_0, 0);
Vars.x_Reshape_26_output_0 = reshape(Vars.x_Range_6_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_15_output_0] = prepareExpandArgs(Vars.x_Concat_34_output_0);
Vars.x_Expand_15_output_0 = Vars.x_Reshape_26_output_0 + zeros(shape);

% Reshape:
[shape, NumDims.x_Reshape_27_output_0] = prepareReshapeArgs(Vars.x_Range_7_output_0, Vars.x_v_1934, NumDims.x_Range_7_output_0, 0);
Vars.x_Reshape_27_output_0 = reshape(Vars.x_Range_7_output_0, shape{:});

% Expand:
[shape, NumDims.x_Expand_16_output_0] = prepareExpandArgs(Vars.x_Concat_34_output_0);
Vars.x_Expand_16_output_0 = Vars.x_Reshape_27_output_0 + zeros(shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_33_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_16_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_16_output_0);
Vars.x_Unsqueeze_33_output_0 = reshape(Vars.x_Expand_16_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_34_output_0] = prepareUnsqueezeArgs(Vars.x_Expand_15_output_0, Vars.x_net_Constant_4_output_0, NumDims.x_Expand_15_output_0);
Vars.x_Unsqueeze_34_output_0 = reshape(Vars.x_Expand_15_output_0, shape);

% Concat:
[Vars.x_Concat_37_output_0, NumDims.x_Concat_37_output_0] = onnxConcat(-1, {Vars.x_Unsqueeze_33_output_0, Vars.x_Unsqueeze_34_output_0}, [NumDims.x_Unsqueeze_33_output_0, NumDims.x_Unsqueeze_34_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_28_output_0] = prepareReshapeArgs(Vars.x_Concat_37_output_0, Vars.x_Constant_26_output_0, NumDims.x_Concat_37_output_0, 0);
Vars.x_Reshape_28_output_0 = reshape(Vars.x_Concat_37_output_0, shape{:});

% Mul:
Vars.x_Mul_25_output_0 = Vars.x_Reshape_28_output_0 .* Vars.x_Constant_27_output_0;
NumDims.x_Mul_25_output_0 = max(NumDims.x_Reshape_28_output_0, NumDims.x_Constant_27_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_35_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_24_output_0, Vars.onnx__Unsqueeze_154, NumDims.x_Gather_24_output_0);
Vars.x_Unsqueeze_35_output_0 = reshape(Vars.x_Gather_24_output_0, shape);

% Concat:
[Vars.x_Concat_38_output_0, NumDims.x_Concat_38_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_35_output_0, Vars.x_Constant_29_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_35_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Constant_29_output_0]);

% Equal:
Vars.x_Equal_9_output_0 = Vars.x_Concat_38_output_0 == Vars.x_Mul_3_output_0;
NumDims.x_Equal_9_output_0 = max(NumDims.x_Concat_38_output_0, NumDims.x_Mul_3_output_0);

% Where:
[Vars.x_Where_9_output_0, NumDims.x_Where_9_output_0] = onnxWhere(Vars.x_Equal_9_output_0, Vars.x_ConstantOfShape_output_0, Vars.x_Concat_38_output_0, NumDims.x_Equal_9_output_0, NumDims.x_ConstantOfShape_output_0, NumDims.x_Concat_38_output_0);

% Expand:
[shape, NumDims.x_Expand_17_output_0] = prepareExpandArgs(Vars.x_Where_9_output_0);
Vars.x_Expand_17_output_0 = Vars.x_Mul_25_output_0 + zeros(shape);

% Transpose:
[perm, NumDims.x_Transpose_6_output_0] = prepareTransposeArgs(Vars.TransposePerm1301, NumDims.x_net_block_fusion_block_fusion_2_3_Co_1);
if ~isempty(perm)
    Vars.x_Transpose_6_output_0 = permute(Vars.x_net_block_fusion_block_fusion_2_3_Co_1, perm);
end

% Concat:
[Vars.x_Concat_39_output_0, NumDims.x_Concat_39_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_35_output_0, Vars.x_Constant_29_output_0, Vars.x_Unsqueeze_6_output_0}, [NumDims.x_Unsqueeze_35_output_0, NumDims.x_Constant_29_output_0, NumDims.x_Unsqueeze_6_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_30_output_0] = prepareReshapeArgs(Vars.x_Transpose_6_output_0, Vars.x_Concat_39_output_0, NumDims.x_Transpose_6_output_0, 0);
Vars.x_Reshape_30_output_0 = reshape(Vars.x_Transpose_6_output_0, shape{:});

% Transpose:
[perm, NumDims.x_Transpose_7_output_0] = prepareTransposeArgs(Vars.TransposePerm1302, NumDims.x_net_heatmap_head_heatmap_head_3_3_Si_1);
if ~isempty(perm)
    Vars.x_Transpose_7_output_0 = permute(Vars.x_net_heatmap_head_heatmap_head_3_3_Si_1, perm);
end

% Concat:
[Vars.x_Concat_40_output_0, NumDims.x_Concat_40_output_0] = onnxConcat(0, {Vars.x_Unsqueeze_35_output_0, Vars.x_Constant_29_output_0}, [NumDims.x_Unsqueeze_35_output_0, NumDims.x_Constant_29_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_31_output_0] = prepareReshapeArgs(Vars.x_Transpose_7_output_0, Vars.x_Concat_40_output_0, NumDims.x_Transpose_7_output_0, 0);
Vars.x_Reshape_31_output_0 = reshape(Vars.x_Transpose_7_output_0, shape{:});

% TopK:
[Vars.x_TopK_3_output_0, Vars.x_TopK_3_output_1, NumDims.x_TopK_3_output_0, NumDims.x_TopK_3_output_1] = onnxTopK11(Vars.x_Reshape_31_output_0, Vars.x_Constant_78_output_0, -1, 1, 1, NumDims.x_Reshape_31_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_39_output_0] = prepareUnsqueezeArgs(Vars.x_TopK_3_output_1, Vars.x_net_Constant_4_output_0, NumDims.x_TopK_3_output_1);
Vars.x_Unsqueeze_39_output_0 = reshape(Vars.x_TopK_3_output_1, shape);

% Expand:
[shape, NumDims.x_Expand_18_output_0] = prepareExpandArgs(Vars.x_Where_1_output_0);
Vars.x_Expand_18_output_0 = Vars.x_Unsqueeze_39_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_6_output_0, NumDims.x_GatherElements_6_output_0] = onnxGatherElements(Vars.x_Reshape_30_output_0, Vars.x_Expand_18_output_0, 1, NumDims.x_Reshape_30_output_0, NumDims.x_Expand_18_output_0);

% Expand:
[shape, NumDims.x_Expand_19_output_0] = prepareExpandArgs(Vars.x_Where_2_output_0);
Vars.x_Expand_19_output_0 = Vars.x_Unsqueeze_39_output_0 + zeros(shape);

% GatherElements:
[Vars.x_GatherElements_7_output_0, NumDims.x_GatherElements_7_output_0] = onnxGatherElements(Vars.x_Expand_17_output_0, Vars.x_Expand_19_output_0, 1, NumDims.x_Expand_17_output_0, NumDims.x_Expand_19_output_0);

% Cast:
if islogical(Vars.x_GatherElements_7_output_0)
    Vars.x_GatherElements_7_output_0 = single(Vars.x_GatherElements_7_output_0);
end
Vars.x_Cast_35_output_0 = single(Vars.x_GatherElements_7_output_0);
NumDims.x_Cast_35_output_0 = NumDims.x_GatherElements_7_output_0;

% Div:
Vars.x_Div_10_output_0 = Vars.x_Cast_26_output_0 ./ Vars.x_Constant_89_output_0;
NumDims.x_Div_10_output_0 = max(NumDims.x_Cast_26_output_0, NumDims.x_Constant_89_output_0);

% Div:
Vars.x_Div_11_output_0 = Vars.x_Cast_35_output_0 ./ Vars.x_Constant_90_output_0;
NumDims.x_Div_11_output_0 = max(NumDims.x_Cast_35_output_0, NumDims.x_Constant_90_output_0);

% Concat:
[Vars.x_Concat_41_output_0, NumDims.x_Concat_41_output_0] = onnxConcat(1, {Vars.x_Div_10_output_0, Vars.x_Div_11_output_0}, [NumDims.x_Div_10_output_0, NumDims.x_Div_11_output_0]);

% Concat:
[Vars.x_Concat_42_output_0, NumDims.x_Concat_42_output_0] = onnxConcat(1, {Vars.x_GatherElements_4_output_0, Vars.x_GatherElements_6_output_0}, [NumDims.x_GatherElements_4_output_0, NumDims.x_GatherElements_6_output_0]);

% Transpose:
[perm, NumDims.x_Transpose_8_output_0] = prepareTransposeArgs(Vars.TransposePerm1303, NumDims.x_Concat_42_output_0);
if ~isempty(perm)
    Vars.x_Transpose_8_output_0 = permute(Vars.x_Concat_42_output_0, perm);
end

% MatMul:
[Vars.x_MatMul_output_0, NumDims.x_MatMul_output_0] = onnxMatMul(Vars.x_Concat_22_output_0, Vars.x_Transpose_8_output_0, NumDims.x_Concat_22_output_0, NumDims.x_Transpose_8_output_0);

% ArgMax:
[Vars.x_ArgMax_output_0, NumDims.x_ArgMax_output_0] = onnxArgMax12(Vars.x_MatMul_output_0, -1, 0, 0, NumDims.x_MatMul_output_0);

% Transpose:
[perm, NumDims.x_Transpose_9_output_0] = prepareTransposeArgs(Vars.TransposePerm1304, NumDims.x_MatMul_output_0);
if ~isempty(perm)
    Vars.x_Transpose_9_output_0 = permute(Vars.x_MatMul_output_0, perm);
end

% ArgMax:
[Vars.x_ArgMax_1_output_0, NumDims.x_ArgMax_1_output_0] = onnxArgMax12(Vars.x_Transpose_9_output_0, -1, 0, 0, NumDims.x_Transpose_9_output_0);

% Gather:
[Vars.x_Gather_28_output_0, NumDims.x_Gather_28_output_0] = onnxGather(Vars.x_ArgMax_1_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_ArgMax_1_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_29_output_0, NumDims.x_Gather_29_output_0] = onnxGather(Vars.x_ArgMax_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_ArgMax_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_30_output_0, NumDims.x_Gather_30_output_0] = onnxGather(Vars.x_Gather_28_output_0, Vars.x_Gather_29_output_0, 0, NumDims.x_Gather_28_output_0, NumDims.x_Gather_29_output_0);

% Equal:
Vars.x_Equal_12_output_0 = Vars.x_Gather_30_output_0 == Vars.onnx__GatherND_1377;
NumDims.x_Equal_12_output_0 = max(NumDims.x_Gather_30_output_0, NumDims.onnx__GatherND_1377);

% NonZero:
[Vars.x_NonZero_output_0, NumDims.x_NonZero_output_0] = onnxNonZero(Vars.x_Equal_12_output_0, NumDims.x_Equal_12_output_0);

% Transpose:
[perm, NumDims.x_Transpose_10_output_0] = prepareTransposeArgs(Vars.TransposePerm1305, NumDims.x_NonZero_output_0);
if ~isempty(perm)
    Vars.x_Transpose_10_output_0 = permute(Vars.x_NonZero_output_0, perm);
end

% GatherND:
[Vars.x_GatherND_output_0, NumDims.x_GatherND_output_0] = onnxGatherND(Vars.onnx__GatherND_1377, Vars.x_Transpose_10_output_0, 0, NumDims.onnx__GatherND_1377, NumDims.x_Transpose_10_output_0);

% GatherND:
[Vars.x_GatherND_1_output_0, NumDims.x_GatherND_1_output_0] = onnxGatherND(Vars.x_Gather_29_output_0, Vars.x_Transpose_10_output_0, 0, NumDims.x_Gather_29_output_0, NumDims.x_Transpose_10_output_0);

% Gather:
[Vars.x_Gather_32_output_0, NumDims.x_Gather_32_output_0] = onnxGather(Vars.x_Concat_22_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Concat_22_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_33_output_0, NumDims.x_Gather_33_output_0] = onnxGather(Vars.x_Gather_32_output_0, Vars.x_GatherND_output_0, 0, NumDims.x_Gather_32_output_0, NumDims.x_GatherND_output_0);

% Gather:
[Vars.x_Gather_34_output_0, NumDims.x_Gather_34_output_0] = onnxGather(Vars.x_Concat_42_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Concat_42_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_35_output_0, NumDims.x_Gather_35_output_0] = onnxGather(Vars.x_Gather_34_output_0, Vars.x_GatherND_1_output_0, 0, NumDims.x_Gather_34_output_0, NumDims.x_GatherND_1_output_0);

% Gather:
[Vars.x_Gather_36_output_0, NumDims.x_Gather_36_output_0] = onnxGather(Vars.x_Concat_18_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Concat_18_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_37_output_0, NumDims.x_Gather_37_output_0] = onnxGather(Vars.x_Gather_36_output_0, Vars.x_GatherND_output_0, 0, NumDims.x_Gather_36_output_0, NumDims.x_GatherND_output_0);

% Gather:
[Vars.x_Gather_38_output_0, NumDims.x_Gather_38_output_0] = onnxGather(Vars.x_Concat_41_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Concat_41_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_39_output_0, NumDims.x_Gather_39_output_0] = onnxGather(Vars.x_Gather_38_output_0, Vars.x_GatherND_1_output_0, 0, NumDims.x_Gather_38_output_0, NumDims.x_GatherND_1_output_0);

% Gather:
[Vars.x_Gather_40_output_0, NumDims.x_Gather_40_output_0] = onnxGather(Vars.x_Concat_21_output_0, Vars.x_Constant_11_output_0, 0, NumDims.x_Concat_21_output_0, NumDims.x_Constant_11_output_0);

% Gather:
[Vars.x_Gather_41_output_0, NumDims.x_Gather_41_output_0] = onnxGather(Vars.x_Gather_40_output_0, Vars.x_GatherND_output_0, 0, NumDims.x_Gather_40_output_0, NumDims.x_GatherND_output_0);

% Concat:
[Vars.x_Concat_43_output_0, NumDims.x_Concat_43_output_0] = onnxConcat(-1, {Vars.x_Gather_33_output_0, Vars.x_Gather_35_output_0}, [NumDims.x_Gather_33_output_0, NumDims.x_Gather_35_output_0]);

% Gemm:
[A, B, C, alpha, beta, NumDims.x_fine_matcher_fine_matcher_0_Gemm_outpu] = prepareGemmArgs(Vars.x_Concat_43_output_0, Vars.net_fine_matcher_0_weight, Vars.net_fine_matcher_0_bias, Vars.Gemmalpha1306, Vars.Gemmbeta1307, 0, 1, NumDims.net_fine_matcher_0_bias);
Vars.x_fine_matcher_fine_matcher_0_Gemm_outpu = alpha*B*A + beta*C;

% BatchNormalization:
[offset, scale, datasetMean, datasetVariance, dataFormat, NumDims.x_fine_matcher_fine_matcher_1_BatchNor_1, NumDims.net_fine_matcher_1_running_mean, NumDims.net_fine_matcher_1_running_var] = prepareBatchNormalizationArgs(Vars.x_fine_matcher_fine_matcher_1_Constant_1, Vars.x_fine_matcher_fine_matcher_1_Constant_o, Vars.net_fine_matcher_1_running_mean, Vars.net_fine_matcher_1_running_var, NumDims.x_fine_matcher_fine_matcher_0_Gemm_outpu, NumDims.net_fine_matcher_1_running_mean, NumDims.net_fine_matcher_1_running_var);
if Training
    [Vars.x_fine_matcher_fine_matcher_1_BatchNor_1, dsmean, dsvar] = batchnorm(Vars.x_fine_matcher_fine_matcher_0_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
    Vars.net_fine_matcher_1_running_mean = dlarray(dsmean);
    Vars.net_fine_matcher_1_running_var = dlarray(dsvar);
else
    Vars.x_fine_matcher_fine_matcher_1_BatchNor_1 = batchnorm(Vars.x_fine_matcher_fine_matcher_0_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
end
state.net_fine_matcher_1_running_mean = Vars.net_fine_matcher_1_running_mean;
state.net_fine_matcher_1_running_var = Vars.net_fine_matcher_1_running_var;

% Relu:
Vars.x_fine_matcher_fine_matcher_2_Relu_outpu = relu(Vars.x_fine_matcher_fine_matcher_1_BatchNor_1);
NumDims.x_fine_matcher_fine_matcher_2_Relu_outpu = NumDims.x_fine_matcher_fine_matcher_1_BatchNor_1;

% Gemm:
[A, B, C, alpha, beta, NumDims.x_fine_matcher_fine_matcher_3_Gemm_outpu] = prepareGemmArgs(Vars.x_fine_matcher_fine_matcher_2_Relu_outpu, Vars.net_fine_matcher_3_weight, Vars.net_fine_matcher_3_bias, Vars.Gemmalpha1308, Vars.Gemmbeta1309, 0, 1, NumDims.net_fine_matcher_3_bias);
Vars.x_fine_matcher_fine_matcher_3_Gemm_outpu = alpha*B*A + beta*C;

% BatchNormalization:
[offset, scale, datasetMean, datasetVariance, dataFormat, NumDims.x_fine_matcher_fine_matcher_4_BatchNor_1, NumDims.net_fine_matcher_4_running_mean, NumDims.net_fine_matcher_4_running_var] = prepareBatchNormalizationArgs(Vars.x_fine_matcher_fine_matcher_1_Constant_1, Vars.x_fine_matcher_fine_matcher_1_Constant_o, Vars.net_fine_matcher_4_running_mean, Vars.net_fine_matcher_4_running_var, NumDims.x_fine_matcher_fine_matcher_3_Gemm_outpu, NumDims.net_fine_matcher_4_running_mean, NumDims.net_fine_matcher_4_running_var);
if Training
    [Vars.x_fine_matcher_fine_matcher_4_BatchNor_1, dsmean, dsvar] = batchnorm(Vars.x_fine_matcher_fine_matcher_3_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
    Vars.net_fine_matcher_4_running_mean = dlarray(dsmean);
    Vars.net_fine_matcher_4_running_var = dlarray(dsvar);
else
    Vars.x_fine_matcher_fine_matcher_4_BatchNor_1 = batchnorm(Vars.x_fine_matcher_fine_matcher_3_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
end
state.net_fine_matcher_4_running_mean = Vars.net_fine_matcher_4_running_mean;
state.net_fine_matcher_4_running_var = Vars.net_fine_matcher_4_running_var;

% Relu:
Vars.x_fine_matcher_fine_matcher_5_Relu_outpu = relu(Vars.x_fine_matcher_fine_matcher_4_BatchNor_1);
NumDims.x_fine_matcher_fine_matcher_5_Relu_outpu = NumDims.x_fine_matcher_fine_matcher_4_BatchNor_1;

% Gemm:
[A, B, C, alpha, beta, NumDims.x_fine_matcher_fine_matcher_6_Gemm_outpu] = prepareGemmArgs(Vars.x_fine_matcher_fine_matcher_5_Relu_outpu, Vars.net_fine_matcher_6_weight, Vars.net_fine_matcher_6_bias, Vars.Gemmalpha1310, Vars.Gemmbeta1311, 0, 1, NumDims.net_fine_matcher_6_bias);
Vars.x_fine_matcher_fine_matcher_6_Gemm_outpu = alpha*B*A + beta*C;

% BatchNormalization:
[offset, scale, datasetMean, datasetVariance, dataFormat, NumDims.x_fine_matcher_fine_matcher_7_BatchNor_1, NumDims.net_fine_matcher_7_running_mean, NumDims.net_fine_matcher_7_running_var] = prepareBatchNormalizationArgs(Vars.x_fine_matcher_fine_matcher_1_Constant_1, Vars.x_fine_matcher_fine_matcher_1_Constant_o, Vars.net_fine_matcher_7_running_mean, Vars.net_fine_matcher_7_running_var, NumDims.x_fine_matcher_fine_matcher_6_Gemm_outpu, NumDims.net_fine_matcher_7_running_mean, NumDims.net_fine_matcher_7_running_var);
if Training
    [Vars.x_fine_matcher_fine_matcher_7_BatchNor_1, dsmean, dsvar] = batchnorm(Vars.x_fine_matcher_fine_matcher_6_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
    Vars.net_fine_matcher_7_running_mean = dlarray(dsmean);
    Vars.net_fine_matcher_7_running_var = dlarray(dsvar);
else
    Vars.x_fine_matcher_fine_matcher_7_BatchNor_1 = batchnorm(Vars.x_fine_matcher_fine_matcher_6_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
end
state.net_fine_matcher_7_running_mean = Vars.net_fine_matcher_7_running_mean;
state.net_fine_matcher_7_running_var = Vars.net_fine_matcher_7_running_var;

% Relu:
Vars.x_fine_matcher_fine_matcher_8_Relu_outpu = relu(Vars.x_fine_matcher_fine_matcher_7_BatchNor_1);
NumDims.x_fine_matcher_fine_matcher_8_Relu_outpu = NumDims.x_fine_matcher_fine_matcher_7_BatchNor_1;

% Gemm:
[A, B, C, alpha, beta, NumDims.x_fine_matcher_fine_matcher_9_Gemm_outpu] = prepareGemmArgs(Vars.x_fine_matcher_fine_matcher_8_Relu_outpu, Vars.net_fine_matcher_9_weight, Vars.net_fine_matcher_9_bias, Vars.Gemmalpha1312, Vars.Gemmbeta1313, 0, 1, NumDims.net_fine_matcher_9_bias);
Vars.x_fine_matcher_fine_matcher_9_Gemm_outpu = alpha*B*A + beta*C;

% BatchNormalization:
[offset, scale, datasetMean, datasetVariance, dataFormat, NumDims.x_fine_matcher_fine_matcher_10_BatchNo_1, NumDims.net_fine_matcher_10_running_mean, NumDims.net_fine_matcher_10_running_var] = prepareBatchNormalizationArgs(Vars.x_fine_matcher_fine_matcher_1_Constant_1, Vars.x_fine_matcher_fine_matcher_1_Constant_o, Vars.net_fine_matcher_10_running_mean, Vars.net_fine_matcher_10_running_var, NumDims.x_fine_matcher_fine_matcher_9_Gemm_outpu, NumDims.net_fine_matcher_10_running_mean, NumDims.net_fine_matcher_10_running_var);
if Training
    [Vars.x_fine_matcher_fine_matcher_10_BatchNo_1, dsmean, dsvar] = batchnorm(Vars.x_fine_matcher_fine_matcher_9_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
    Vars.net_fine_matcher_10_running_mean = dlarray(dsmean);
    Vars.net_fine_matcher_10_running_var = dlarray(dsvar);
else
    Vars.x_fine_matcher_fine_matcher_10_BatchNo_1 = batchnorm(Vars.x_fine_matcher_fine_matcher_9_Gemm_outpu, offset, scale, datasetMean, datasetVariance, 'Epsilon', 1.000000e-05, 'DataFormat', dataFormat);
end
state.net_fine_matcher_10_running_mean = Vars.net_fine_matcher_10_running_mean;
state.net_fine_matcher_10_running_var = Vars.net_fine_matcher_10_running_var;

% Relu:
Vars.x_fine_matcher_fine_matcher_11_Relu_outp = relu(Vars.x_fine_matcher_fine_matcher_10_BatchNo_1);
NumDims.x_fine_matcher_fine_matcher_11_Relu_outp = NumDims.x_fine_matcher_fine_matcher_10_BatchNo_1;

% Gemm:
[A, B, C, alpha, beta, NumDims.x_fine_matcher_fine_matcher_12_Gemm_outp] = prepareGemmArgs(Vars.x_fine_matcher_fine_matcher_11_Relu_outp, Vars.net_fine_matcher_12_weight, Vars.net_fine_matcher_12_bias, Vars.Gemmalpha1314, Vars.Gemmbeta1315, 0, 1, NumDims.net_fine_matcher_12_bias);
Vars.x_fine_matcher_fine_matcher_12_Gemm_outp = alpha*B*A + beta*C;

% Mul:
Vars.x_Mul_30_output_0 = Vars.x_fine_matcher_fine_matcher_12_Gemm_outp .* Vars.x_Constant_188_output_0;
NumDims.x_Mul_30_output_0 = max(NumDims.x_fine_matcher_fine_matcher_12_Gemm_outp, NumDims.x_Constant_188_output_0);

% Softmax:
[Vars.x_Softmax_output_0, NumDims.x_Softmax_output_0] = onnxSoftmax13(Vars.x_Mul_30_output_0, -1, NumDims.x_Mul_30_output_0);

% ReduceMax:
dims = prepareReduceArgs(Vars.ReduceMaxAxes1316, NumDims.x_Softmax_output_0);
Vars.x_ReduceMax_output_0 = max(Vars.x_Softmax_output_0, [], dims);
[Vars.x_ReduceMax_output_0, NumDims.x_ReduceMax_output_0] = onnxSqueeze(Vars.x_ReduceMax_output_0, Vars.ReduceMaxAxes1316, NumDims.x_Softmax_output_0);

% Reshape:
[shape, NumDims.x_Reshape_34_output_0] = prepareReshapeArgs(Vars.x_Softmax_output_0, Vars.x_Constant_189_output_0, NumDims.x_Softmax_output_0, 0);
Vars.x_Reshape_34_output_0 = reshape(Vars.x_Softmax_output_0, shape{:});

% Mul:
Vars.x_Mul_33_output_0 = Vars.x_Cast_42_output_0 .* Vars.x_Reshape_34_output_0;
NumDims.x_Mul_33_output_0 = max(NumDims.x_Cast_42_output_0, NumDims.x_Reshape_34_output_0);

% Mul:
Vars.x_Mul_34_output_0 = Vars.x_Cast_43_output_0 .* Vars.x_Reshape_34_output_0;
NumDims.x_Mul_34_output_0 = max(NumDims.x_Cast_43_output_0, NumDims.x_Reshape_34_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_45_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_33_output_0, Vars.x_Constant_37_output_0, NumDims.x_Mul_33_output_0);
Vars.x_Unsqueeze_45_output_0 = reshape(Vars.x_Mul_33_output_0, shape);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_46_output_0] = prepareUnsqueezeArgs(Vars.x_Mul_34_output_0, Vars.x_Constant_37_output_0, NumDims.x_Mul_34_output_0);
Vars.x_Unsqueeze_46_output_0 = reshape(Vars.x_Mul_34_output_0, shape);

% Concat:
[Vars.x_Concat_49_output_0, NumDims.x_Concat_49_output_0] = onnxConcat(-1, {Vars.x_Unsqueeze_45_output_0, Vars.x_Unsqueeze_46_output_0}, [NumDims.x_Unsqueeze_45_output_0, NumDims.x_Unsqueeze_46_output_0]);

% Reshape:
[shape, NumDims.x_Reshape_39_output_0] = prepareReshapeArgs(Vars.x_Concat_49_output_0, Vars.x_v_676, NumDims.x_Concat_49_output_0, 0);
Vars.x_Reshape_39_output_0 = reshape(Vars.x_Concat_49_output_0, shape{:});

% ReduceSum:
dims = prepareReduceArgs(Vars.onnx__ReduceSum_169, NumDims.x_Reshape_39_output_0);
Vars.x_ReduceSum_output_0 = sum(Vars.x_Reshape_39_output_0, dims);
[Vars.x_ReduceSum_output_0, NumDims.x_ReduceSum_output_0] = onnxSqueeze(Vars.x_ReduceSum_output_0, Vars.onnx__ReduceSum_169, NumDims.x_Reshape_39_output_0);

% Unsqueeze:
[shape, NumDims.x_Unsqueeze_49_output_0] = prepareUnsqueezeArgs(Vars.x_Gather_41_output_0, Vars.onnx__ReduceSum_169, NumDims.x_Gather_41_output_0);
Vars.x_Unsqueeze_49_output_0 = reshape(Vars.x_Gather_41_output_0, shape);

% Mul:
Vars.x_Mul_35_output_0 = Vars.x_ReduceSum_output_0 .* Vars.x_Unsqueeze_49_output_0;
NumDims.x_Mul_35_output_0 = max(NumDims.x_ReduceSum_output_0, NumDims.x_Unsqueeze_49_output_0);

% Add:
Vars.x_Add_output_0 = Vars.x_Gather_37_output_0 + Vars.x_Mul_35_output_0;
NumDims.x_Add_output_0 = max(NumDims.x_Gather_37_output_0, NumDims.x_Mul_35_output_0);

% Greater:
Vars.x_Greater_output_0 = Vars.x_ReduceMax_output_0 > Vars.x_Constant_212_output_0;
NumDims.x_Greater_output_0 = max(NumDims.x_ReduceMax_output_0, NumDims.x_Constant_212_output_0);

% NonZero:
[Vars.x_NonZero_2_output_0, NumDims.x_NonZero_2_output_0] = onnxNonZero(Vars.x_Greater_output_0, NumDims.x_Greater_output_0);

% Transpose:
[perm, NumDims.x_Transpose_12_output_0] = prepareTransposeArgs(Vars.TransposePerm1317, NumDims.x_NonZero_2_output_0);
if ~isempty(perm)
    Vars.x_Transpose_12_output_0 = permute(Vars.x_NonZero_2_output_0, perm);
end

% GatherND:
[Vars.x_GatherND_2_output_0, NumDims.x_GatherND_2_output_0] = onnxGatherND(Vars.x_Add_output_0, Vars.x_Transpose_12_output_0, 0, NumDims.x_Add_output_0, NumDims.x_Transpose_12_output_0);

% GatherND:
[Vars.x_GatherND_3_output_0, NumDims.x_GatherND_3_output_0] = onnxGatherND(Vars.x_Gather_39_output_0, Vars.x_Transpose_12_output_0, 0, NumDims.x_Gather_39_output_0, NumDims.x_Transpose_12_output_0);

% Concat:
[Vars.x_Concat_51_output_0, NumDims.x_Concat_51_output_0] = onnxConcat(-1, {Vars.x_GatherND_2_output_0, Vars.x_GatherND_3_output_0}, [NumDims.x_GatherND_2_output_0, NumDims.x_GatherND_3_output_0]);

% Split:
[Vars.matched_points1, Vars.matched_points2, NumDims.matched_points1, NumDims.matched_points2] = onnxSplit13(Vars.x_Concat_51_output_0, 1, Vars.onnx__Split_179, 2, NumDims.x_Concat_51_output_0);

% Set graph output arguments from Vars and NumDims:
matched_points1 = Vars.matched_points1;
matched_points1NumDims1320 = NumDims.matched_points1;
matched_points2 = Vars.matched_points2;
matched_points2NumDims1321 = NumDims.matched_points2;
% Set output state from Vars:
state = updateStruct(state, Vars);
end

function [inputDataPerms, outputDataPerms, Training] = parseInputs(input1, input2, numDataOutputs, params, varargin)
% Function to validate inputs to xfeat:
p = inputParser;
isValidArrayInput = @(x)isnumeric(x) || isstring(x);
isValidONNXParameters = @(x)isa(x, 'ONNXParameters');
addRequired(p, 'input1', isValidArrayInput);
addRequired(p, 'input2', isValidArrayInput);
addRequired(p, 'params', isValidONNXParameters);
addParameter(p, 'InputDataPermutation', 'auto');
addParameter(p, 'OutputDataPermutation', 'auto');
addParameter(p, 'Training', false);
parse(p, input1, input2, params, varargin{:});
inputDataPerms = p.Results.InputDataPermutation;
outputDataPerms = p.Results.OutputDataPermutation;
Training = p.Results.Training;
if isnumeric(inputDataPerms)
    inputDataPerms = {inputDataPerms};
end
if isstring(inputDataPerms) && isscalar(inputDataPerms) || ischar(inputDataPerms)
    inputDataPerms = repmat({inputDataPerms},1,2);
end
if isnumeric(outputDataPerms)
    outputDataPerms = {outputDataPerms};
end
if isstring(outputDataPerms) && isscalar(outputDataPerms) || ischar(outputDataPerms)
    outputDataPerms = repmat({outputDataPerms},1,numDataOutputs);
end
end

function [input1, input2, Training, outputDataPerms, anyDlarrayInputs] = preprocessInput(input1, input2, params, varargin)
% Parse input arguments
[inputDataPerms, outputDataPerms, Training] = parseInputs(input1, input2, 2, params, varargin{:});
anyDlarrayInputs = any(cellfun(@(x)isa(x, 'dlarray'), {input1, input2}));
% Make the input variables into unlabelled dlarrays:
input1 = makeUnlabeledDlarray(input1);
input2 = makeUnlabeledDlarray(input2);
% Permute inputs if requested:
input1 = permuteInputVar(input1, inputDataPerms{1}, 4);
input2 = permuteInputVar(input2, inputDataPerms{2}, 4);
% Check input size(s):
checkInputSize(size(input1), {1 3 'height' 'width'}, "input1");
checkInputSize(size(input2), {1 3 'height' 'width'}, "input2");
end

function [matched_points1, matched_points2] = postprocessOutput(matched_points1, matched_points2, outputDataPerms, anyDlarrayInputs, Training, varargin)
% Set output type:
if ~anyDlarrayInputs && ~Training
    if isdlarray(matched_points1)
        matched_points1 = extractdata(matched_points1);
    end
    if isdlarray(matched_points2)
        matched_points2 = extractdata(matched_points2);
    end
end
% Permute outputs if requested:
matched_points1 = permuteOutputVar(matched_points1, outputDataPerms{1}, 2);
matched_points2 = permuteOutputVar(matched_points2, outputDataPerms{2}, 2);
end


%% dlarray functions implementing ONNX operators:

function [Y, numDimsY] = onnxArgMax12(X, ONNXAxis, keepdims, selectLastIndex, numDimsX)
% Implements the ONNX ArgMax operator.

% Copyright 2021 The MathWorks, Inc.

if ONNXAxis < 0
    ONNXAxis = ONNXAxis + numDimsX;
end
DLTAxis = numDimsX - ONNXAxis;
if selectLastIndex % New in Opset 12
    X2 = flip(X, DLTAxis);
    [~, DLTI] = max(X2, [], DLTAxis);
    Y = size(X, DLTAxis) - DLTI;
else
    [~, DLTI] = max(X, [], DLTAxis);
    Y = DLTI - 1;
end
if keepdims
    numDimsY = numDimsX;
else
    Y = onnxSqueeze(Y, ONNXAxis, numDimsX);
    numDimsY = numDimsX - 1;
end
end

function [Y, numDimsY] = onnxConcat(ONNXAxis, XCell, numDimsXArray)
% Concatentation that treats all empties the same. Necessary because
% dlarray.cat does not allow, for example, cat(1, 1x1, 1x0) because the
% second dimension sizes do not match.

% Copyright 2021 The MathWorks, Inc.

numDimsY = numDimsXArray(1);
XCell(cellfun(@isempty, XCell)) = [];
if isempty(XCell)
    Y = dlarray([]);
else
    if ONNXAxis<0
        ONNXAxis = ONNXAxis + numDimsY;
    end
    DLTAxis = numDimsY - ONNXAxis;
    Y = cat(DLTAxis, XCell{:});
end
end

function [Y, numDimsY] = onnxConstantOfShape(value, ONNXShape)
% Returns a DLT tensor with the reverse of the ONNXShape.

% Copyright 2020 The MathWorks, Inc.

DLTShape = fliplr(extractdata(ONNXShape(:)'));
numDimsY = numel(DLTShape);
switch numDimsY
    case 0
        % If shape is empty, output is a scalar
        Y = value;
    case 1
        Y = ones(DLTShape,1) .* value;
    otherwise
        Y = ones(DLTShape) .* value;
end
end

function [Y, numDimsY] = onnxGather(X, ONNXIdx, ONNXAxis, numDimsX, numDimsIdx)
% Function implementing the ONNX Gather operator

% In ONNX, 'Gather' first indexes into dimension ONNXAxis of data, using
% the contents of ONNXIdx as the indices. Then, it reshapes the ONNXAxis
% into the shape of ONNXIdx.
%   Example 1:
% Suppose data has shape [2 3 4 5], ONNXIdx has shape [6 7], and axis=1.
% The result has shape [2 6 7 4 5].
%   Example 2:
% Suppose data has shape [2 3 4 5], ONNXIdx has shape [6], and axis=1.
% The result has shape [2 6 4 5].
%   Example 3:
% Suppose data has shape [2 3 4 5], ONNXIdx has shape [] (a scalar), and axis=1.
% The result has shape [2 4 5].
%
% Since we're using reverse indexing relative to ONNX, in this function
% data and ONNXIdx both have reversed dimension ordering.

% Copyright 2020-2021 The MathWorks, Inc.

numDimsY = numDimsIdx + (numDimsX - 1);
if isempty(X)
    Y = X;
    return;
end
% (1) First, do the subsref part of Gather
if ONNXAxis<0
    ONNXAxis = ONNXAxis + numDimsX;                                 % Axis can be negative. Convert it to its positive equivalent.
end
dltAxis = numDimsX - ONNXAxis;                                      % Convert axis to DLT. ONNXAxis is origin 0 and we index from the end
ONNXIdx(ONNXIdx<0) = ONNXIdx(ONNXIdx<0) + size(X, dltAxis);         % ONNXIdx can have negative components. Make them positive.
dltIdx  = extractdata(ONNXIdx) + 1;                                 % ONNXIdx is origin-0 in ONNX, so add 1 to get dltIdx
% Use subsref to index into data
Indices.subs = repmat({':'}, 1, numDimsX);
Indices.subs{dltAxis} = dltIdx(:);                                  % Index as a column to ensure the output is 1-D in the indexed dimension (for now).
Indices.type = '()';
Y = subsref(X, Indices);
% (2) Now do the reshaping part of Gather
shape = size(Y, 1:numDimsX);
if numDimsIdx == 0
    % Delete the indexed dimension
    shape(dltAxis) = [];
elseif numDimsIdx > 1
    % Reshape the indexed dimension into the shape of ONNXIdx
    shape = [shape(1:dltAxis-1) size(ONNXIdx, 1:numDimsIdx) shape(dltAxis+1:end)];
end
% Extend the shape to 2D so it's valid MATLAB
if numel(shape) < 2
    shape = [shape ones(1,2-numel(shape))];
end
Y = reshape(Y, shape);
end

function [Y, numDimsY] = onnxGatherElements(X, ONNXIndices, ONNXAxis, numDimsX, numDimsIndices)

% Copyright 2022 The MathWorks, Inc.

% Implements the ONNX GatherElements operator
if ONNXAxis<0
    ONNXAxis = ONNXAxis + numDimsX;                                 % Axis can be negative. Convert it to its positive equivalent.
end
% Convert axis to DLT axis. ONNXAxis is origin 0 and we index dimensions in
% reverse ONNX ordering
mlAxis = numDimsX - ONNXAxis;
% Convert ONNXIndices to DLT.
ONNXIndices(ONNXIndices<0) = ONNXIndices(ONNXIndices<0) + size(X,mlAxis);  % Make negative ONNXIndices nonnegative.
mlIndices = ONNXIndices + 1;
% Find the linear indices of X from which we Gather the data
mlLinearIndices = gatherElementsLinearIndices(X, mlAxis, mlIndices);
% Get the elements, then reshape to the shape of Indices
Y = reshape(X(mlLinearIndices), size(ONNXIndices));
numDimsY = numDimsIndices;

    function L = gatherElementsLinearIndices(X,dim,Indices)
        % Reduce to 0-based.
        L = Indices;
        L = L - 1;
        if dim > 1
            % Shift to be the component from the relevant dimension.
            L = L*prod(size(X, 1:(dim-1)));
        end
        sz = 1;
        % Go through the dims of X.
        for d = 1:ndims(X)
            if d ~= dim
                % Add in the component from this dimension.
                idx = ((1:size(Indices,d))-1)*sz;                   % Note we take the size of Indices here, not X.
                szvec = [ones(1, d-1),  numel(idx), 1];
                L = L + reshape(idx, szvec);
            end
            % Increase the cumulative size.
            sz = sz * size(X,d);
        end
        % Shift back to being 1-based.
        L = L(:) + 1;
    end

end

function [dlY, numDimsY] = onnxGatherND(dlX, dlI, batch_dims, numDimsX, numDimsIndices)
% Implements the ONNX GatherND operator
% X and indices passed in reverse ONNX format.
% ONNX representation: [<batchShape>,<tupleHolderShape>,<slice>]
% MATLAB representation: [<slice>,<tupleHolderShape>,<batchShape>]

% Copyright 2024 The MathWorks, Inc.

dlX = stripdims(dlX);
dlI = stripdims(dlI);
r = numDimsX;
q = numDimsIndices;
b = batch_dims;
k = size(dlI,1);   % In ONNX, shape of I is [<batchShape>, <tupleHolderShape>, k], so k is first in reverse-ONNX.

% r>=1 and q>=1 are to be honored.
assert(r>=1 && q>=1,message('nnet_cnn_onnx:onnx:RankSmallerThanOne',"onnxGatherND"))
% b < min(q,r) is to be honored
assert(b<min(q,r),message("nnet_cnn_onnx:onnx:BatchDimsLargerThanRank", "onnxGatherND"));
% The k should have a value between 1(inclusive) and rank "r-b" (inclusive)
assert(k>= 1 && k<=(r-b),message("nnet_cnn_onnx:onnx:GatherNDInvalidK", "onnxGatherND"));

% Convert the indices stored in indices from origin-0 to origin-1
dlI = dlI + 1;
dlI = flip(dlI,1);

% calculate numDimsY
numDimsY = max(1,q+r-k-1-b);
% Calculate the indice shape in the dlX
indiceShape = size(dlI,2:q-b);
if k==r-b
    % Flatten out tupleHolderShape and batchShape in indices.
    dlI = reshape(dlI, k, []);    % [k N]
    % Compute linear indices of indexs to gather
    for i = k:-1:1
        ICell{i} = dlI(i,:)';
    end
    % Compute the indices of gathered data in each batch
    gatherShape = size(dlX, 1:r-b);
    if numel(gatherShape)<2
        gatherShape = [gatherShape, ones(1,2-numel(gatherShape))];
    end
    gatherSize = prod(gatherShape);
    linIdx = sub2ind(gatherShape, ICell{:});
    % Add batch indices to each slice
    [linIdx,batchShape] = addBatchIndice(dlX,r, b,linIdx,gatherSize);

    dlY = dlX(linIdx);                                                              % dlY in shape [indices Size * batch Size]
    dlY = reshape(dlY,[indiceShape, batchShape]);                                   % dlY in shape [<indices shape>, <batchs shape>]
else
    % Flatten out tupleHolderShape and batchShape in indices.
    dlI = reshape(dlI, k, []);                                                      % shape is [k N]
    % Compute linear indices of indexs to gather
    for i = k:-1:1
        ICell{i} = dlI(i,:)';
    end
    % Compute the indices of gathered data in each batch
    subSpaceShape = size(dlX, r-b-k+1:r-b);                                         % The k dims of dlX to apply the indices.
    if numel(subSpaceShape)<2
        subSpaceShape = [subSpaceShape, ones(1,2-numel(subSpaceShape))];
    end
    subspaceLinIdx = sub2ind(subSpaceShape, ICell{:});                              % Linear indices as if they indexed only the last k dims.
    leadDataShape = size(dlX, 1:r-b-k);
    numelLeadingData = prod(leadDataShape);                                         % Total number of elements in the first r-k dimensions of dlX.
    linIdxMat = (subspaceLinIdx(:)-1)'*numelLeadingData + (1:numelLeadingData)';    % Adding a row to a column to get a matrix!
    linIdx = linIdxMat(:);
    % Add the batch indices to each indices
    gatherShape = size(dlX, 1:r-b);
    gatherSize = prod(gatherShape);
    [linIdx,batchShape] = addBatchIndice(dlX,r,b,linIdx,gatherSize);

    dlY = dlX(linIdx);                                                              % dlY in shape [r, indices Size * batch Size]
    dlY = reshape(dlY,[leadDataShape, indiceShape, batchShape]);                    % dlY in shape [r,<indices shape>, <batchs shape>]
end

    function [linIdx,batchShape] = addBatchIndice(dlX,r, b,linIdx,gatherSize)
        if b == 0
            batchShape = 1;
            return;
        else
            % Add the batch indices to each indices
            batchShape = size(dlX, r-b+1:r);                                            % The last b dims of dlX.
            if numel(batchShape)<2
                batchShape = [batchShape, ones(1,2-numel(batchShape))];
            end
            batchSize = prod(batchShape);
            batchSpaceLinIdx = 1:batchSize;
            batchSpaceLinIdx = repmat(batchSpaceLinIdx,size(linIdx,1)/batchSize,1);
            linIdx = ((batchSpaceLinIdx(:)-1)'*gatherSize)' + linIdx;                   % Adding a row to a column to get a matrix!
        end
    end
end
function [D, numDimsD] = onnxMatMul(A, B, numDimsA, numDimsB)
% Implements the ONNX MatMul operator.

% Copyright 2020-2023 The MathWorks, Inc.

% If B is 1-D, temporarily extend it to a row vector
if numDimsB==1
    B = B(:)';
end
maxNumDims = max(numDimsA, numDimsB);
numDimsD = maxNumDims;
if maxNumDims > 2
    % Removes dlarray formats if only one of the input dlarrays is formatted.
    if sum([isempty(dims(A)), isempty(dims(B))]) == 1
        D = pagemtimes(stripdims(B), stripdims(A));
    else
        %computes matrix product of corresponding pages of input arrays A and
        %B.
        D = pagemtimes(B, A);
    end
else
    D = B * A;
    if numDimsA==1 || numDimsB==1
        D = D(:);
        numDimsD = 1;
    end
end
end

function [Y, numDimsY] = onnxNonZero(X, numDimsX)

% Copyright 2020 The MathWorks, Inc.

% Implements the ONNX NonZero operator
Coords      = cell(1,max(2,numDimsX));
% Extract the coordinates of the nonzero points
[Coords{:}] = ind2sub(size(X, 1:max(2,numDimsX)), find(extractdata(X)~=0));
% Concatenate the coordinates into a 2D matrix
Y = [Coords{:}];
% Subtract 1 to convert to origin 0
Y = Y - 1;
if numDimsX < 2
    Y = Y(:,1);
end
Y = dlarray(Y);
numDimsY = 2;
end

function [Y, numDimsY] = onnxShape(X, numDimsX, startAxis, endAxis)
% Implements the ONNX Shape operator
% Return the reverse ONNX shape as a 1D column vector

% Copyright 2020-2024 The MathWorks, Inc.

switch numDimsX
    case 0
        if isempty(X)
            Y = dlarray(0);
        else
            Y = dlarray(1);
        end
    case 1
        if isempty(X)
            Y = dlarray(0);
        else
            Y = dlarray(size(X,1));
        end
    otherwise
        if(endAxis<0)
            %  If the endAxis is smaller than 0 after converting it positive,
            % the endAxis is 0
            endAxis = max(0, numDimsX + endAxis);
        end
        if(startAxis<0)
            %  If the startAxis is smaller than 0 after converting it positive,
            % the startAxis is 0
            startAxis = max(0, numDimsX + startAxis);
        end
        % transform startAxis and endAxis from 0 index to 1 index
        startAxis = startAxis + 1;
        endAxis = endAxis + 1;
        % if startAxis is larger than numDimsX or endAxis is larger than
        % numDimsX + 1, cramp it to the upper bound. The endAxis is exclusive,
        % transform it to MATLAB inclusive way
        endAxis = min(endAxis, numDimsX + 1) - 1;
        startAxis = min(startAxis, numDimsX);
        if endAxis < startAxis || endAxis == 0
            Y = dlarray(0);
        else
            Y = dlarray(fliplr(size(X, (numDimsX-endAxis+1):(numDimsX-startAxis+1)))');
        end
end
numDimsY = 1;
end

function [Y, numDimsY] = onnxSoftmax13(X, ONNXaxis, numDimsX)
% Implements the ONNX Softmax function:
% Softmax(input, axis) = Exp(input) / ReduceSum(Exp(input), axis=axis, keepdims=1)
% The input is constrained to floating point types.

% Copyright 2021 The MathWorks, Inc.

if ONNXaxis < 0
    ONNXaxis = ONNXaxis + numDimsX;
end
DLTaxis = numDimsX - ONNXaxis;

X = X - max(X, [], DLTaxis); % Subtract max(X) for numerical stability
expX = exp(X);
dims = prepareReduceArgs(ONNXaxis, numDimsX);
Y = expX ./ sum(expX, dims);
numDimsY = numDimsX;

end
function varargout = onnxSplit13(X, ONNXaxis, splits, numSplits, numDimsX)
% Implements the ONNX Split operator

% Copyright 2021-2024 The MathWorks, Inc.

% ONNXaxis is origin 0. splits is a vector of the lengths of each segment.
% If splits is empty, instead split into segments of equal length.
if ONNXaxis<0
    ONNXaxis = ONNXaxis + numDimsX;
end
DLTAxis = numDimsX - ONNXaxis;
if isempty(splits)
    C       = size(X, DLTAxis);
    sz      = floor(C/numSplits);
    splits	= repmat(sz, 1, numSplits);
else
    splits = extractdata(splits);
end
S      = struct;
S.type = '()';
S.subs = repmat({':'}, 1, numDimsX);        % Important to use numDimsX. ndims(X) may be too small.
splitIndices = [0 cumsum(splits(:)')];
numY = numel(splitIndices)-1;
for i = 1:numY
    from            = splitIndices(i) + 1;
    to              = splitIndices(i+1);
    S.subs{DLTAxis}	= from:to;
    % The first numY outputs are the Y's. The second numY outputs are their
    % numDims. We assume all the outputs of Split have the same numDims as
    % the input.
    varargout{i}        = subsref(X, S);
    varargout{i + numY} = numDimsX;
end
end

function [Y, numDimsY] = onnxSqueeze(X, ONNXAxes, numDimsX)
% Implements the ONNX Squeeze operator

% Copyright 2020 The MathWorks, Inc.

if numDimsX == 0
    Y = X;
    numDimsY = numDimsX;
else
    % Find the new ONNX shape
    curOShape = size(X, numDimsX:-1:1);
    if isempty(ONNXAxes)
        newOShape = curOShape(curOShape ~= 1);
    else
        ONNXAxes(ONNXAxes<0) = ONNXAxes(ONNXAxes<0) + numDimsX;
        newOShape = curOShape;
        newOShape(ONNXAxes+1) = [];
    end
    % Get numDimsY from ONNX shape
    numDimsY  = numel(newOShape);
    newMShape = [fliplr(newOShape) ones(1, 2-numDimsY)];    % Append 1's to shape if numDims<2
    Y         = reshape(X, newMShape);
end
end

function [T, I, numDimsT, numDimsI] = onnxTopK11(X, K, ONNXAxis, largest, sorted, numDimsX)
% Implements the ONNX TopK operator. If largest==1, return the K largest,
% otherwise the K smallest. If sorted==1, return them in sorted order.
% Otherwise the returned order is undefined.

% Copyright 2020 The MathWorks, Inc.

if ONNXAxis < 0
    ONNXAxis = ONNXAxis + numDimsX;
end
DLTDim = numDimsX - ONNXAxis;
if isa(K, 'dlarray')
    K = extractdata(K);
end
% To support largest=0, pass -X to maxk to get the indices of the smallest
% elements.
if largest==1
    XtoUse = X;
else
    XtoUse = -X;
end
% To support sorted, do nothing. Our maxk always returns the elements in
% sorted order. In ONNX, when sorted=0, the order is undefined, meaning
% that sorted order is still acceptable.
[I, IlinInd] = maxklinind(extractdata(XtoUse), K, DLTDim);
% I contains indices for each subscript along the axis dim. IlinInd
% contains the linear indices into X.
T = X(IlinInd);
% T, and I (origin-0), are what the ONNX operator returns:
I = dlarray(I - 1);
numDimsT = numDimsX;
numDimsI = numDimsX;

    function [I, IlinInd] = maxklinind(A,k,dim)
        % Gather indices.
        [~,I] = maxk(A,k,dim);
        % Reduce to 0-based.
        IlinInd = I;
        IlinInd = IlinInd - 1;
        if dim > 1
            % Shift to be the component from the relevant dimension.
            IlinInd = IlinInd*prod(size(A, 1:(dim-1)));
        end
        sz = 1;
        % Go through the dims of A.
        for d = 1:ndims(A)
            if d ~= dim
                % Add in the component from this dimension.
                idx = ((1:size(A,d))-1)*sz;
                szvec = [ones(1, d-1),  numel(idx), 1];
                IlinInd = IlinInd + reshape(idx, szvec);
            end
            % Increase the cumulative size.
            sz = sz * size(A,d);
        end
        % Shift back to being 1-based.
        IlinInd = IlinInd + 1;
    end
end

function [output, numDimsOutput] = onnxWhere(condition, X, Y, numDimsCondition, numDimsX, numDimsY)

% Copyright 2020 The MathWorks, Inc.

bigz = zeros(size(condition + X + Y));      % broadcast
condition = condition + bigz;
X = X + bigz;
output = Y + bigz;
output(condition==1) = X(condition==1);
numDimsOutput = max([numDimsCondition, numDimsX, numDimsY]);
end

function [poolSize, stride, padding, paddingValue, dataFormat, numDimsY] = prepareAveragePoolArgs(poolSize, stride, padding, count_include_pad, numDimsX)

%   Copyright 2020-2020 The MathWorks, Inc.

% Prepares arguments for implementing the ONNX AveragePool operator
poolSize    = fliplr(extractdata(poolSize(:)'));
stride      = fliplr(extractdata(stride(:)'));
if isa(padding, 'dlarray')
    padding = extractdata(padding);
end
if isnumeric(padding)
    % ONNX: [x1_begin, ..., xn_begin, x1_end, ...,xn_end]
    % DLT:  [xn_begin, ..., x1_begin;
    %        xn_end, ..., x1_end]       (Note the fliplr and semicolon)
    padding = fliplr(transpose(reshape(padding, [], 2)));
end
if logical(count_include_pad)
    paddingValue = 0;
else
    paddingValue = 'mean';
end
dataFormat  = [repmat('S', 1, numDimsX-2) 'CB'];
numDimsY = numDimsX;
end

function [offset, scale, datasetMean, datasetVariance, dataFormat, numDimsY, numDimsDatasetMean, numDimsDatasetVariance] = prepareBatchNormalizationArgs(...
    offset, scale, datasetMean, datasetVariance, numDimsX, numDimsDatasetMean, numDimsDatasetVariance)
% Prepares arguments for implementing the ONNX BatchNormalization operator

%   Copyright 2020-2021 The MathWorks, Inc.

offset = dlarray(offset,'C');
scale = dlarray(scale,'C');
datasetMean = extractdata(datasetMean);
datasetVariance = extractdata(datasetVariance);
datasetVariance(datasetVariance <= 0) = realmin('single');  % Set nonpositive variance components to a value below eps('single')
dataFormat = [repmat('S', 1, numDimsX-2), 'CB'];
numDimsY = numDimsX;
end

function [weights, bias, stride, dilationFactor, padding, dataFormat, numDimsY] = prepareConvArgs(...
    weights, bias, stride, dilationFactor, padding, numWtGroups, numDimsX, numDimsW)
% Prepares arguments for implementing the ONNX Conv operator

%   Copyright 2020 The MathWorks, Inc.

% Weights: The ONNX weight dim is Fcxyz..., where c=C/G, G is numGroups,
% and xyz... are spatial dimensions. DLT "weights" here is the flip of
% that, or ...zyxcF. dlconv requires ...zyxcfG, where f=F/G. So reshape to
% split the last dimension.
sizeW    = size(weights, 1:numDimsW);
F        = sizeW(end);
newWSize = [sizeW(1:numDimsW-1), F/numWtGroups, numWtGroups];
weights  = reshape(weights, newWSize);
% bias
if isempty(bias)
    bias = 0;
end
bias = dlarray(bias(:),'CU');
% Derive missing default attributes from weight tensor
numSpatialDims = numDimsW-2;
if isempty(padding)
    padding = zeros(1, 2*numSpatialDims);
end
if isempty(stride)
    stride = ones(1,numSpatialDims);
end
if isempty(dilationFactor)
    dilationFactor = ones(1,numSpatialDims);
end
% Make the attributes non-dlarrays:
if isa(stride, 'dlarray')
    stride = extractdata(stride);
end
if isa(dilationFactor, 'dlarray')
    dilationFactor = extractdata(dilationFactor);
end
if isa(padding, 'dlarray')
    padding = extractdata(padding);
end
% Make the attributes double row vectors, and flip their dimension ordering
% to reverse-onnx:
stride = fliplr(double(stride(:)'));
dilationFactor = fliplr(double(dilationFactor(:)'));
if isnumeric(padding)       % padding can be "same"
    % ONNX: [x1_begin, ..., xn_begin, x1_end, ...,xn_end]
    % DLT:  [xn_begin, ..., x1_begin;
    %        xn_end, ..., x1_end]       (Note the lrflip and semicolon)
    padding = fliplr(transpose(reshape(padding, [], 2)));
end
% Set dataformat and numdims
dataFormat = [repmat('S', 1, numDimsX-2) 'CB'];
numDimsY = numDimsX;
end

function [shape, numDimsY] = prepareExpandArgs(ONNXShape)
% Prepares arguments for implementing the ONNX Expand operator

%   Copyright 2020 The MathWorks, Inc.

% Broadcast X to ONNXShape. The shape of X must be compatible with ONNXShape.
ONNXShape = extractdata(ONNXShape);
shape = fliplr(ONNXShape(:)');
if numel(shape) < 2
    shape = [shape ones(1, 2-numel(shape))];
end
numDimsY = numel(ONNXShape);
end

function [A, B, C, alpha, beta, numDimsY] = prepareGemmArgs(A, B, C, alpha, beta, transA, transB, numDimsC)

%   Copyright 2020 The MathWorks, Inc.

% Prepares arguments for implementing the ONNX Gemm operator
if transA
    A = A';
end
if transB
    B = B';
end
if numDimsC < 2
    C = C(:);   % C can be broadcast to [N M]. Make C a col vector ([N 1])
end
numDimsY = 2;
% Y=B*A because we want (AB)'=B'A', and B and A are already transposed.
end

function dims = prepareReduceArgs(ONNXAxes, numDimsX)
% Prepares arguments for implementing the ONNX Reduce operator

%   Copyright 2020 The MathWorks, Inc.

if isempty(ONNXAxes)
    ONNXAxes = 0:numDimsX-1;   % All axes
end
ONNXAxes(ONNXAxes<0) = ONNXAxes(ONNXAxes<0) + numDimsX;
dims = numDimsX - ONNXAxes;
end

function [DLTShape, numDimsY] = prepareReshapeArgs(X, ONNXShape, numDimsX, allowzero)
% Prepares arguments for implementing the ONNX Reshape operator

%   Copyright 2020-2024 The MathWorks, Inc.

ONNXShape = flip(extractdata(ONNXShape));            % First flip the shape to make it correspond to the dimensions of X.
% In ONNX, 0 means "unchanged" if allowzero is false, and -1 means "infer". In DLT, there is no
% "unchanged", and [] means "infer".
DLTShape = num2cell(ONNXShape);                      % Make a cell array so we can include [].
% Replace zeros with the actual size if allowzero is false
if any(ONNXShape==0) && allowzero==0
    i0 = find(ONNXShape==0);
    DLTShape(i0) = num2cell(size(X, numDimsX - numel(ONNXShape) + i0));  % right-align the shape vector and dims
end
if any(ONNXShape == -1)
    % Replace -1 with []
    i = ONNXShape == -1;
    DLTShape{i} = [];
end
if numel(DLTShape)==1
    DLTShape = [DLTShape 1];
end
numDimsY = numel(ONNXShape);
end

function [DLTScales, DLTSizes, dataFormat, Method, GeometricTransformMode, NearestRoundingMode, numDimsY] = prepareResize11Args(...
    ONNXRoi, ONNXScales, ONNXSizes, coordinate_transformation_mode, mode, nearest_mode, numDimsX)
% Prepares arguments for implementing the ONNX Resize-11 operator

%   Copyright 2020-2024 The MathWorks, Inc.

% ONNXScales and ONNXSizes are in ONNX dimension ordering. ONNXRoi is
% ignored because it only takes effect when coordinate_transformation_mode
% is "tf_crop_and_resize", which is not supported.
DLTScales = flip(extractdata(ONNXScales(:)'));
DLTSizes = flip(extractdata(ONNXSizes(:)'));
switch coordinate_transformation_mode
    case "half_pixel"
        GeometricTransformMode = "half-pixel";
    case "asymmetric"
        GeometricTransformMode = "asymmetric";
    otherwise
        assert(false);
end
switch mode
    case "nearest"
        Method = "nearest";
    case "linear"
        Method = "linear";
    otherwise
        assert(false);
end
switch nearest_mode
    case "floor"
        NearestRoundingMode = "floor";
    otherwise
        NearestRoundingMode = "round";
end
dataFormat = repmat('S', [1 numDimsX]);
numDimsY = numDimsX;
end

function [S, numDimsY] = prepareSliceArgs(X, Starts, Ends, Axes, Steps, numDimsX)
% Prepares arguments for implementing the ONNX Slice operator

%   Copyright 2020 The MathWorks, Inc.

% Starts, Ends and Axes are all origin 0. Axes refer to the ONNX dimension
% ordering, but X uses the reverse, DLT ordering. Starts, Ends, Axes, and
% Steps correspond positionally. Axes and Steps may be omitted, with
% defaults described in the ONNX spec.

% Set default Axes and Steps if not supplied
if isempty(Axes)
    Axes = 0:numDimsX-1;   % All axes
end
Axes(Axes<0) = Axes(Axes<0) + numDimsX; % Handle negative Axes.
if isempty(Steps)
    Steps = ones(1, numel(Starts));
end
% Init all dims to :
S.subs = repmat({':'}, 1, numDimsX);
S.type = '()';
% Set Starts and Ends for each axis
for i = 1:numel(Axes)
    DLTDim = numDimsX - Axes(i);                                               % The DLT dim is the reverse of the ONNX dim.
    % "If a negative value is passed for any of the start or end indices,
    % it represents number of elements before the end of that dimension."
    if Starts(i) < 0
        Starts(i) = size(X,DLTDim) + Starts(i);
    end
    if Ends(i) < 0
        Ends(i) = max(-1, size(X,DLTDim) + Ends(i));                        % The -1 case is when we're slicing backward and want to include 0.
    end
    % "If the value passed to start or end is larger than the n (the number
    % of elements in this dimension), it represents n."
    if Starts(i) > size(X,DLTDim)
        Starts(i) = size(X,DLTDim);
    end
    if Ends(i) > size(X,DLTDim)
        Ends(i) = size(X,DLTDim);
    end
    if Steps(i) > 0
        S.subs{DLTDim} = 1 + (Starts(i) : Steps(i) : Ends(i)-1);            % 1 + (Origin 0 indexing with end index excluded)
    else
        S.subs{DLTDim} = 1 + (Starts(i) : Steps(i) : Ends(i)+1);            % 1 + (Origin 0 indexing with end index excluded)
    end
end
numDimsY = numDimsX;
end

function [perm, numDimsA] = prepareTransposeArgs(ONNXPerm, numDimsA)
% Prepares arguments for implementing the ONNX Transpose operator

%   Copyright 2020 The MathWorks, Inc.

if numDimsA <= 1        % Tensors of numDims 0 or 1 are unchanged by ONNX Transpose.
    perm = [];
else
    if isempty(ONNXPerm)        % Empty ONNXPerm means reverse the dimensions.
        perm = numDimsA:-1:1;
    else
        perm = numDimsA-flip(ONNXPerm);
    end
end
end

function [newShape, numDimsY] = prepareUnsqueezeArgs(X, ONNXAxes, numDimsX)
% Prepares arguments for implementing the ONNX Unsqueeze operator

%   Copyright 2020-2021 The MathWorks, Inc.

numDimsY = numDimsX + numel(ONNXAxes);
ONNXAxes = extractdata(ONNXAxes);
ONNXAxes(ONNXAxes<0) = ONNXAxes(ONNXAxes<0) + numDimsY;
ONNXAxes = sort(ONNXAxes);                                              % increasing order
if numDimsY == 1
    newShape = size(X);
else
    DLTAxes  = flip(numDimsY - ONNXAxes);                                  % increasing order
    newShape = ones(1, numDimsY);
    posToSet = setdiff(1:numDimsY, DLTAxes, 'stable');
    newShape(posToSet) = size(X, 1:numel(posToSet));
end
end

%% Utility functions:

function s = appendStructs(varargin)
% s = appendStructs(s1, s2,...). Assign all fields in s1, s2,... into s.

%   Copyright 2020 The MathWorks, Inc.

if isempty(varargin)
    s = struct;
else
    s = varargin{1};
    for i = 2:numel(varargin)
        fromstr = varargin{i};
        fs = fieldnames(fromstr);
        for j = 1:numel(fs)
            s.(fs{j}) = fromstr.(fs{j});
        end
    end
end
end

function checkInputSize(inputShape, expectedShape, inputName)

%   Copyright 2020-2021 The MathWorks, Inc.

if numel(expectedShape)==0
    % The input is a scalar
    if ~isequal(inputShape, [1 1])
        inputSizeStr = makeSizeString(inputShape);
        error(message('nnet_cnn_onnx:onnx:InputNeedsResize',inputName, "[1,1]", inputSizeStr));
    end
elseif numel(expectedShape)==1
    % The input is a vector
    if ~shapeIsColumnVector(inputShape) || ~iSizesMatch({inputShape(1)}, expectedShape)
        expectedShape{2} = 1;
        expectedSizeStr = makeSizeString(expectedShape);
        inputSizeStr = makeSizeString(inputShape);
        error(message('nnet_cnn_onnx:onnx:InputNeedsResize',inputName, expectedSizeStr, inputSizeStr));
    end
else
    % The input has 2 dimensions or more

    % The input dimensions have been reversed; flip them back to compare to the
    % expected ONNX shape.
    inputShape = fliplr(inputShape);

    % If the expected shape has fewer dims than the input shape, error.
    if numel(expectedShape) < numel(inputShape)
        expectedSizeStr = strjoin(["[", strjoin(string(expectedShape), ","), "]"], "");
        error(message('nnet_cnn_onnx:onnx:InputHasGreaterNDims', inputName, expectedSizeStr));
    end

    % Prepad the input shape with trailing ones up to the number of elements in
    % expectedShape
    inputShape = num2cell([ones(1, numel(expectedShape) - length(inputShape)) inputShape]);

    % Find the number of variable size dimensions in the expected shape
    numVariableInputs = sum(cellfun(@(x) isa(x, 'char') || isa(x, 'string'), expectedShape));

    % Find the number of input dimensions that are not in the expected shape
    % and cannot be represented by a variable dimension
    nonMatchingInputDims = setdiff(string(inputShape), string(expectedShape));
    numNonMatchingInputDims  = numel(nonMatchingInputDims) - numVariableInputs;

    expectedSizeStr = makeSizeString(expectedShape);
    inputSizeStr = makeSizeString(inputShape);
    if numNonMatchingInputDims == 0 && ~iSizesMatch(inputShape, expectedShape)
        % The actual and expected input dimensions match, but in
        % a different order. The input needs to be permuted.
        error(message('nnet_cnn_onnx:onnx:InputNeedsPermute',inputName, expectedSizeStr, inputSizeStr));
    elseif numNonMatchingInputDims > 0
        % The actual and expected input sizes do not match.
        error(message('nnet_cnn_onnx:onnx:InputNeedsResize',inputName, expectedSizeStr, inputSizeStr));
    end
end
end

function doesMatch = iSizesMatch(inputShape, expectedShape)
% Check whether the input and expected shapes match, in order.
% Size elements match if (1) the elements are equal, or (2) the expected
% size element is a variable (represented by a character vector or string)
doesMatch = true;
for i=1:numel(inputShape)
    if ~(isequal(inputShape{i},expectedShape{i}) || ischar(expectedShape{i}) || isstring(expectedShape{i}))
        doesMatch = false;
        return
    end
end
end

function sizeStr = makeSizeString(shape)
sizeStr = strjoin(["[", strjoin(string(shape), ","), "]"], "");
end

function isVec = shapeIsColumnVector(shape)
if numel(shape) == 2 && shape(2) == 1
    isVec = true;
else
    isVec = false;
end
end
function X = makeUnlabeledDlarray(X)
% Make numeric X into an unlabelled dlarray

%   Copyright 2020-2021 The MathWorks, Inc.

if isa(X, 'dlarray')
    X = stripdims(X);
elseif isnumeric(X)
    if isinteger(X)
        % Make ints double so they can combine with anything without
        % reducing precision
        X = double(X);
    end
    X = dlarray(X);
end
end

function [Vars, NumDims] = packageVariables(params, inputNames, inputValues, inputNumDims)

%   Copyright 2020 The MathWorks, Inc.

% inputNames, inputValues are cell arrays. inputRanks is a numeric vector.
Vars = appendStructs(params.Learnables, params.Nonlearnables, params.State);
NumDims = params.NumDimensions;
% Add graph inputs
for i = 1:numel(inputNames)
    Vars.(inputNames{i}) = inputValues{i};
    NumDims.(inputNames{i}) = inputNumDims(i);
end
end

function X = permuteInputVar(X, userDataPerm, onnxNDims)

%   Copyright 2020-2021 The MathWorks, Inc.
% Returns reverse-ONNX ordering
if onnxNDims == 0
    return;
elseif onnxNDims == 1 && isvector(X)
    X = X(:);
    return;
elseif isnumeric(userDataPerm)
    % Permute into reverse ONNX ordering
    if numel(userDataPerm) ~= onnxNDims
        error(message('nnet_cnn_onnx:onnx:InputPermutationSize', numel(userDataPerm), onnxNDims));
    end
    perm = fliplr(userDataPerm);
elseif isequal(userDataPerm, 'auto') && onnxNDims == 4
    % Permute MATLAB HWCN to reverse onnx (WHCN)
    perm = [2 1 3 4];
elseif isequal(userDataPerm, 'as-is')
    % Do not permute the input
    perm = 1:ndims(X);
else
    % userDataPerm is either 'none' or 'auto' with no default, which means
    % it's already in onnx ordering, so just make it reverse onnx
    perm = max(2,onnxNDims):-1:1;
end
X = permute(X, perm);
end

function Y = permuteOutputVar(Y, userDataPerm, onnxNDims)

%   Copyright 2020-2021 The MathWorks, Inc.
switch onnxNDims
    case 0
        perm = [];
    case 1
        if isnumeric(userDataPerm)
            % Use the user's permutation because Y is a column vector which
            % already matches ONNX.
            perm = userDataPerm;
        elseif isequal(userDataPerm, 'auto')
            % Treat the 1D onnx vector as a 2D column and transpose it
            perm = [2 1];
        else
            % userDataPerm is 'none'. Leave Y alone because it already
            % matches onnx.
            perm = [];
        end
    otherwise
        % ndims >= 2
        if isnumeric(userDataPerm)
            % Use the inverse of the user's permutation. This is not just the
            % flip of the permutation vector.
            perm = onnxNDims + 1 - userDataPerm;
        elseif isequal(userDataPerm, 'auto')
            if onnxNDims == 2
                % Permute reverse ONNX CN to DLT CN (do nothing)
                perm = [];
            elseif onnxNDims == 4
                % Permute reverse onnx (WHCN) to MATLAB HWCN
                perm = [2 1 3 4];
            else
                % User wants the output in ONNX ordering, so just reverse it from
                % reverse onnx
                perm = onnxNDims:-1:1;
            end
        elseif isequal(userDataPerm, 'as-is')
            % Do not permute the input
            perm = 1:ndims(Y);
        else
            % userDataPerm is 'none', so just make it reverse onnx
            perm = onnxNDims:-1:1;
        end
end
if ~isempty(perm)
    Y = permute(Y, perm);
end
end

function s = updateStruct(s, t)
% Set all existing fields in s from fields in t, ignoring extra fields in
% t.
%   Copyright 2020 The MathWorks, Inc.

for name = transpose(fieldnames(s))
    s.(name{1}) = t.(name{1});
end
end