Find the bug in the second shader, the first one is correct.
```
      struct Uniforms { output_size:u32, scales:vec4<f32>, roi:array<vec4<f32>, 2>, input_shape:vec4<u32>, input_strides:vec4<u32>, output_shape:vec4<u32>, output_strides:vec4<u32> };
      @group(0) @binding(2) var<uniform> uniforms: Uniforms;
  fn i2o_input(indices: vec4<u32>) -> u32 {
    return uniforms.input_strides[3] * (indices[3])+uniforms.input_strides[2] * (indices[2])+uniforms.input_strides[1] * (indices[1])+uniforms.input_strides[0] * (indices[0]);
  }

  fn get_inputByIndices(indices: vec4<u32>) -> f32 {
    return input[i2o_input(indices)];
  }

  fn o2i_output(offset: u32) -> vec4<u32> {
    var indices: vec4<u32>;
    var current = offset;
    
    let dim0 = current / uniforms.output_strides[0];
    let rest0 = current % uniforms.output_strides[0];
    indices[0] = dim0;
    current = rest0;
    
    let dim1 = current / uniforms.output_strides[1];
    let rest1 = current % uniforms.output_strides[1];
    indices[1] = dim1;
    current = rest1;
    
    let dim2 = current / uniforms.output_strides[2];
    let rest2 = current % uniforms.output_strides[2];
    indices[2] = dim2;
    current = rest2;
    indices[3] = current;
    return indices;
  }

      
      fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,
     lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> f32 { if (lengthResized > 1) {
                    return (f32(xResized) + 0.5) / f32(xScale) - 0.5;
                  } else {
                    return 0.0;
                  }};
      
              
    fn calculateOriginalIndicesFromOutputIndices(output_indices: vec4<u32>) -> array<f32, 4> {
      var original_indices: array<f32, 4>;
      for (var i:u32 = 0; i < 4; i++) {
        var output_index = output_indices[i];
        var scale = uniforms.scales[i];
        var roi_low = uniforms.roi[(i) / 4][(i) % 4];
        var roi_hi = uniforms.roi[(i + 4) / 4][(i + 4) % 4];
        if (scale == 1.0) {
          original_indices[i] = f32(output_index);
        } else {
          var input_shape_i = uniforms.input_shape[i];
          var output_shape_i = uniforms.output_shape[i];
          original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,
                                                                           input_shape_i, roi_low, roi_hi);
        }
      }
      return original_indices;
    };
              
    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> f32 {
      var input_indices: vec4<u32>;
      input_indices[2]=max(0, min(row, 360 - 1));;
      input_indices[3]=max(0, min(col, 640 - 1));;
      
    input_indices[1]=channel;;
    input_indices[0]=batch;;

      return get_inputByIndices(input_indices);
    }

    fn bilinearInterpolation(output_indices: vec4<u32>) -> f32 {
      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);
      var row:f32 = originalIndices[2];
      var col:f32 = originalIndices[3];
      ;
      row = max(0, min(row, 360 - 1));
      col = max(0, min(col, 640 - 1));
      var row1: u32 = u32(row);
      var col1: u32 = u32(col);
      var row2: u32 = u32(row + 1);
      var col2: u32 = u32(col + 1);
      var channel: u32 = u32(originalIndices[1]);
      var batch: u32 =  u32(originalIndices[0]);
      var x11: f32 = getInputValue(batch, channel, row1, col1);
      var x12: f32 = getInputValue(batch, channel, row1, col2);
      var x21: f32 = getInputValue(batch, channel, row2, col1);
      var x22: f32 = getInputValue(batch, channel, row2, col2);
      var dx1: f32 = abs(row - f32(row1));
      var dx2: f32 = abs(f32(row2) - row);
      var dy1: f32 = abs(col - f32(col1));
      var dy2: f32 = abs(f32(col2) - col);
      if (row1 == row2) {
        dx1 = 0.5;
        dx2 = 0.5;
      }
      if (col1 == col2) {
        dy1 = 0.5;
        dy2 = 0.5;
      }
      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);
    };
            ;
      
      @group(0) @binding(0) var<storage, read> input: array<f32>;
@group(0) @binding(1) var<storage, read_write> output: array<f32>;
      @compute @workgroup_size(64, 1, 1)
  fn main(@builtin(global_invocation_id) global_id : vec3<u32>,
    @builtin(workgroup_id) workgroup_id : vec3<u32>,
    @builtin(local_invocation_index) local_idx : u32,
    @builtin(local_invocation_id) local_id : vec3<u32>) {
    let global_idx = global_id.x;
         let workgroup_index = workgroup_id.x;
  
        if (global_idx >= uniforms.output_size) { return; }
        
        let output_indices = o2i_output(global_idx);
        var input_indices: vec4<u32>;
        output[global_idx] = bilinearInterpolation(output_indices);;

      }
```

```

const workgroup_size_x: u32 = 64;
const workgroup_size_y: u32 = 1;
const workgroup_size_z: u32 = 1;
@group(0) @binding(0) var<storage, read> input: array<f32>;
@group(0) @binding(1) var<storage, read_write> output: array<f32>;
struct Uniforms {
  input_shape: vec4<u32>,
  input_stride: vec3<u32>,
  output_shape: vec4<u32>,
  output_stride: vec3<u32>,
  output_size: u32,
  scales: vec4<f32>,
  roi: array<vec4<f32>, 2>
};
@group(0) @binding(2) var<uniform> uniforms: Uniforms;

alias input_value_t = f32;
alias input_indices_t = vec4<u32>;
fn i2o_input(indices : input_indices_t)->u32 {
  return indices[0] * uniforms.input_stride[0] + indices[1] * uniforms.input_stride[1] + indices[2] * uniforms.input_stride[2] + indices[3];
}
fn get_input_by_indices(indices: input_indices_t)->input_value_t {
  return input[i2o_input(indices)];
}
alias output_value_t = f32;
alias output_indices_t = vec4<u32>;
fn o2i_output(offset : u32)->output_indices_t {
  var indices: output_indices_t;
  var current = offset;
  let dim0 = current / uniforms.output_stride[0];
  let rest0 = current % uniforms.output_stride[0];
  indices[0] = dim0;
  current = rest0;
  let dim1 = current / uniforms.output_stride[1];
  let rest1 = current % uniforms.output_stride[1];
  indices[1] = dim1;
  current = rest1;
  let dim2 = current / uniforms.output_stride[2];
  let rest2 = current % uniforms.output_stride[2];
  indices[2] = dim2;
  current = rest2;
  indices[3] = current;
  return indices;
}

fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32, lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> f32 {
  if (lengthResized > 1) {
    return (f32(xResized) + 0.5) / f32(xScale) - 0.5;
  } else {
    return 0.0;
  }
}

fn calculateOriginalIndicesFromOutputIndices(output_indices: output_indices_t) -> array<output_value_t, 4> {
  var original_indices: array<output_value_t, 4>;
  for (var i: u32 = 0u; i < 4u; i = i + 1u) {
    let output_index = output_indices[i];
    let scale = uniforms.scales[i];
    let roi_low = uniforms.roi[(i) / 4][(i) % 4];
    let roi_hi = uniforms.roi[(i + 4) / 4][(i + 4) % 4];
    if (scale == 1.0) {
      original_indices[i] = output_value_t(output_index);
    } else {
      let input_shape_i = uniforms.input_shape[i];
      let output_shape_i = uniforms.output_shape[i];
      original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,
                                                                       input_shape_i, roi_low, roi_hi);
    }
  }
  return original_indices;
}
    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> input_value_t {
      var input_indices: input_indices_t;
      input_indices[2]=max(0, min(row, 359));
      input_indices[3]=max(0, min(col, 639));
      
      return get_input_by_indices(input_indices);
    }

    fn bilinearInterpolation(output_indices: output_indices_t) -> input_value_t {
      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);
      var row:input_value_t = originalIndices[2];
      var col:input_value_t = originalIndices[3];
      row = max(0, min(row, 360 - 1));
      col = max(0, min(col, 640 - 1));
      var row1: u32 = u32(row);
      var col1: u32 = u32(col);
      var row2: u32 = u32(row + 1);
      var col2: u32 = u32(col + 1);
      var channel: u32 = u32(originalIndices[1]);
      var batch: u32 =  u32(originalIndices[0]);
      var x11: input_value_t = getInputValue(batch, channel, row1, col1);
      var x12: input_value_t = getInputValue(batch, channel, row1, col2);
      var x21: input_value_t = getInputValue(batch, channel, row2, col1);
      var x22: input_value_t = getInputValue(batch, channel, row2, col2);
      var dx1: input_value_t = abs(row - input_value_t(row1));
      var dx2: input_value_t = abs(input_value_t(row2) - row);
      var dy1: input_value_t = abs(col - input_value_t(col1));
      var dy2: input_value_t = abs(input_value_t(col2) - col);
      if (row1 == row2) {
        dx1 = 0.5;
        dx2 = 0.5;
      }
      if (col1 == col2) {
        dy1 = 0.5;
        dy2 = 0.5;
      }
      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);
    }
@compute @workgroup_size(workgroup_size_x, workgroup_size_y, workgroup_size_z)
fn main(@builtin(global_invocation_id) global_id : vec3<u32>,
        @builtin(workgroup_id) workgroup_id : vec3<u32>,
        @builtin(local_invocation_index) local_idx : u32,
        @builtin(local_invocation_id) local_id : vec3<u32>) {
  let global_idx = global_id.x;
  let workgroup_idx = workgroup_id.x;
  if (global_idx >= uniforms.output_size) { return; }

  let output_indices = o2i_output(global_idx);
  var input_indices: input_indices_t;
  output[global_idx] = bilinearInterpolation(output_indices);

}

```