namespace mlir {
namespace TF {

SmallVector<int64_t, 4> ReversePermutation(ArrayRef<int64_t> permutation) {
  SmallVector<int64_t, 4> reverse(permutation.size());
  for (size_t i = 0; i < permutation.size(); ++i) {
    reverse[permutation[i]] = i;
  }
  return reverse;
}

SmallVector<int64_t, 4> GetDataFormatPermutation(StringRef from, StringRef to) {
  if (from == "NHWC" && to == "NCHW") {
    return {0, 3, 1, 2};

    private static final byte[] DECODE_TABLE = new byte[128];
    static {
        for (int i = 0; i < DECODE_TABLE.length; i++) {
            DECODE_TABLE[i] = Byte.MAX_VALUE;
        }
        for (int i = 0; i < ENCODE_TABLE.length; i++) {
            DECODE_TABLE[ENCODE_TABLE[i]] = (byte) i;
        }
    }

    /**
     * Base64でエンコードします。
     *
     * @param inData
     *            エンコードするデータ

  for (i in namesAndValues.indices) {
    require(namesAndValues[i] != null) { "Headers cannot be null" }
    namesAndValues[i] = inputNamesAndValues[i].trim()
  }

  // Check for malformed headers.
  for (i in namesAndValues.indices step 2) {
    val name = namesAndValues[i]
    val value = namesAndValues[i + 1]
    headersCheckName(name)
    headersCheckValue(value, name)

        readShorts(decoder, array);
        return array;
    }

    public static void readShorts(Decoder decoder, short[] array) throws IOException {
        for (int i = 0; i < array.length; i++) {
            array[i] = decoder.readShort();
        }
    }

    public static int[] readLengthPrefixedInts(Decoder decoder) throws IOException {
        int length = decoder.readInt();

	var cunlock atomic.Bool
	cdone := make(chan bool)
	for i := 0; i < numReaders; i++ {
		go parallelReader(&m, clocked, &cunlock, cdone)
	}
	// Wait for all parallel RLock()s to succeed.
	for i := 0; i < numReaders; i++ {
		<-clocked
	}
	cunlock.Store(true)
	// Wait for the goroutines to finish.
	for i := 0; i < numReaders; i++ {
		<-cdone
	}
}

func TestParallelRWMutexReaders(t *testing.T) {

    }

    public <I> ModelAction action(ModelPath modelPath, ModelType<I> inputType, BiAction<? super T, ? super I> action) {
        return action(modelPath, inputType, inputType.toString(), action);
    }

    public <I> ModelAction action(String modelPath, ModelType<I> inputType, BiAction<? super T, ? super I> action) {
        return action(modelPath, inputType, modelPath, action);
    }

	s1 := New[int]()
	for i := 0; i < 100; i++ {
		s1.Insert(i)
	}
	s2 := New[int]()
	for i := 0; i < 100; i += 2 {
		s2.Insert(i)
	}
	b.ResetTimer()

	b.Run("Difference", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			s1.Difference(s2)
		}
	})
	b.Run("DifferenceInPlace", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			s1.DifferenceInPlace(s2)
		}
	})

	"testing"
)

func TestAll(t *testing.T) {
	for size := 0; size < 10; size++ {
		m := make(map[int]int)
		for i := range size {
			m[i] = i
		}
		cnt := 0
		for i, v := range All(m) {
			v1, ok := m[i]
			if !ok || v != v1 {
				t.Errorf("at iteration %d got %d, %d want %d, %d", cnt, i, v, i, v1)
			}
			cnt++
		}
		if cnt != size {
			t.Errorf("read %d values expected %d", cnt, size)
		}
	}
}

  for (size_t i = 0; i < num_loop_vars; ++i) {
    enter_outputs[i] = internal::Enter(scope, inputs[i], frame_name);
  }
  TF_RETURN_IF_ERROR(scope.status());

  std::vector<Output> merge_outputs(num_loop_vars);
  for (size_t i = 0; i < num_loop_vars; ++i) {
    TF_RETURN_IF_ERROR(
        CreateMerge(scope, i, enter_outputs[i], &merge_outputs[i]));
  }

  Output cond_out;

	"testing"
)

func TestTrailingZeros64(t *testing.T) {
	for i := 0; i <= 64; i++ {
		x := uint64(5) << uint(i)
		if got := sys.TrailingZeros64(x); got != i {
			t.Errorf("TrailingZeros64(%d)=%d, want %d", x, got, i)
		}
	}
}
func TestTrailingZeros32(t *testing.T) {
	for i := 0; i <= 32; i++ {
		x := uint32(5) << uint(i)
		if got := sys.TrailingZeros32(x); got != i {
			t.Errorf("TrailingZeros32(%d)=%d, want %d", x, got, i)
		}