code: def rot90(input, k, dims):
      total_dims = ivy.get_num_dims(input)
      total_rot_dims = len(dims)
  
      ivy.utils.assertions.check_greater(
          total_dims,
          2,
          allow_equal=True,
          message="expected total dims >= 2, but got total dims = "
          + str(total_dims),
          as_array=False,
      )
  
      ivy.utils.assertions.check_equal(
          total_rot_dims,
          2,
          message="expected total rotation dims == 2, but got dims = "
          + str(total_rot_dims),
          as_array=False,
      )
  
      ivy.utils.assertions.check_equal(
          dims[0],
          dims[1],
          inverse=True,
          message="expected rotation dims to be different, but got dim0 = "
          + str(dims[0])
          + " and dim1 = "
          + str(dims[1]),
          as_array=False,
      )
  
      ivy.utils.assertions.check_equal(
          ivy.abs(dims[0] - dims[1]),
          total_dims,
          inverse=True,
          message="expected rotation dims to be different, but got dim0 = "
          + str(dims[0])
          + " and dim1 = "
          + str(dims[1]),
      )
  
      # range of dims
      ivy.utils.assertions.check_less(
          dims[0],
          total_dims,
          message="Rotation dim0 out of range, dim0 = " + str(dims[0]),
          as_array=False,
      )
  
      ivy.utils.assertions.check_greater(
          dims[0],
          -total_dims,
          allow_equal=True,
          message="Rotation dim0 out of range, dim0 = " + str(dims[0]),
          as_array=False,
      )
  
      ivy.utils.assertions.check_less(
          dims[1],
          total_dims,
          message="Rotation dim1 out of range, dim1 = " + str(dims[1]),
          as_array=False,
      )
  
      ivy.utils.assertions.check_greater(
          dims[1],
          -total_dims,
          allow_equal=True,
          message="Rotation dim1 out of range, dim1 = " + str(dims[1]),
          as_array=False,
      )
  
      k = (4 + (k % 4)) % 4
      new_axes = list(range(total_dims))
      new_axes[min(dims)], new_axes[max(dims)] = max(dims), min(dims)
      if k == 1:
          flipped = ivy.flip(input, axis=dims[1])
          return ivy.permute_dims(flipped, axes=new_axes, copy=True)
      elif k == 2:
          return ivy.flip(input, axis=dims, copy=True)
      elif k == 3:
          flipped = ivy.flip(input, axis=dims[0])
          return ivy.permute_dims(flipped, axes=new_axes, copy=True)
      else:
          return input
  
imports: import ivy
  from ivy.func_wrapper import with_unsupported_dtypes, with_supported_dtypes
  from ivy.functional.frontends.torch.func_wrapper import to_ivy_arrays_and_back
  from ivy.functional.frontends.torch import promote_types_of_torch_inputs
  import ivy.functional.frontends.torch
label_desc: Use image node_id 34 for calling a global function with example usage: rot90(input, k, dims) and returns: ivy, ivy, ivy, input