code: def get_inverse_transform_indices(
      transform_tile: callable, tile_size: Tuple[int, int]
  ):
      """
      Compute a permutation of indices that invert the specified (tiled) matrix transformation
  
      :param transform_tile: a function that applies forward transform to a tensor of shape [dim1, dim2]
      :param tile_size: higher-level tile dimensions, i.e. (8, 32) for Turing and (32, 32) for Ampere
      :note: we assume that tile_transform applies to a cpu-based int8 tensor of shape tile_size
      :example: transform_tile function for the turing layout (bitsandbytes.functional as F)
      :returns: indices
      """
      d1, d2 = tile_size
      assert 0 < d1 * d2 < 2**64
      tile_indices = torch.arange(d1 * d2, dtype=torch.int64).view(
          d1, d2
      )
      # encode each position in tile as a tuple of <= 8 unique bytes
      permuted_tile_indices = torch.zeros_like(tile_indices)
      for i in range(8):
          # select i-th byte, apply transformation and trace where each index ended up
          ith_dim_indices = (
              torch.div(tile_indices, 256**i, rounding_mode="trunc")
              % 256
          )
          sample_tile_i = (
              (ith_dim_indices - 128).to(torch.int8).contiguous()
          )
          assert torch.all(
              sample_tile_i.int() + 128 == ith_dim_indices
          ), "int overflow"
          permuted_tile_i = transform_tile(sample_tile_i)
          ith_permuted_indices = (
              permuted_tile_i.to(tile_indices.dtype) + 128
          )
          permuted_tile_indices += ith_permuted_indices * (256**i)
          if d1 * d2 < 256**i:
              break  # if all indices fit in i bytes, stop early
      return permuted_tile_indices
  
imports: import operator
  import warnings
  from dataclasses import dataclass
  from functools import reduce
  from typing import Tuple, Optional, List
  from warnings import warn
  import torch
  import bitsandbytes.functional
label_desc: Use image node_id 2 for calling a global function with example usage: get_inverse_transform_indices(transform_tile, tile_size) and returns: permuted_tile_indices