return transpose_op.emitOpError(
            "perm tensor elements size is not equal to input tensor rank");
      }
    }

    // Get permutation axes of the TransposeOp
    DenseIntElementsAttr perm;
    if (!matchPattern(transpose_op.getPerm(), m_Constant(&perm))) {
      return failure();
    }

    SmallVector<int64_t, 4> axes;
    for (const auto& axis_int : perm.getValues<APInt>()) {

				seed += int64(IntN(Int()))
				seed += int64(Int32N(Int32()))
				seed += int64(Int64N(Int64()))
				seed += int64(NormFloat64())
				seed += int64(Uint32())
				seed += int64(Uint64())
				for _, p := range Perm(10) {
					seed += int64(p)
				}
			}
			_ = seed
		}(i)
	}

func main() {
	for _, name := range []string{"go.mod", "go.sum"} {
		fi, err := os.Stat(name)
		if err != nil {
			fmt.Fprintf(os.Stderr, "%s: %v\n", err)
			continue
		}
		fmt.Printf("%s: 0%o\n", name, fi.Mode().Perm())
	}
}
-- go.mod --
module TODO

go 1.14
-- go.sum --
-- go.mod.want --
module golang.org/issue/34634

go 1.14

require rsc.io/sampler v1.99.99
-- go.sum.want --

func.func @fold_into_pad_with_extra_uses(%arg0: tensor<1x2x4x4x3xf32>) -> (tensor<1x2x3x4x4xf32>, tensor<1x2x3x6x6xf32>) {

  // CHECK: %[[PERM:.*]] = "tf.Const"() <{value = dense<[0, 1, 4, 2, 3]> : tensor<5xi32>}>
  // CHECK: %[[TRANSPOSE_OP:[0-9]*]] = "tf.Transpose"(%arg0, %[[PERM]])
  // CHECK: %[[PADDING:.*]] = "tf.Const"() <{value = dense<{{\[\[}}0, 0], [0, 0], [1, 1], [1, 1], [0, 0]]> : tensor<5x2xi32>}>

// from the default Source.
func Float32() float32 { return globalRand.Float32() }

// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers
// in the half-open interval [0,n) from the default Source.
func Perm(n int) []int { return globalRand.Perm(n) }

// Shuffle pseudo-randomizes the order of elements using the default Source.

	"os"
	"path/filepath"
	"syscall"
)

func access(name string) error {
	_, err := os.Lstat(name)
	return err
}

func osMkdirAll(dirPath string, perm os.FileMode, _ string) error {
	// baseDir is not honored in windows platform
	return os.MkdirAll(dirPath, perm)
}

// readDirFn applies the fn() function on each entries at dirPath, doesn't recurse into

    Operation supports folding operand(s) transposes into the operation itself.

    (1) Operation might have layout dependent operands and results...

      Example:  MaxPool(Transpose($arg, $perm))
                  -> Transpose(MaxPool($arg, $perm))

    (2) ... or it might have only layout dependent operands:

      Example: Mean(Transpose($arg, $reduction_dims))
                 -> Mean($arg, Transpose($reduction_dims))
  }];

// It returns a non-negative number of bytes written or a negative errno value.
//
//go:noescape
func write1(fd uintptr, p unsafe.Pointer, n int32) int32

//go:noescape
func open(name *byte, mode, perm int32) int32

// return value is only set on linux to be used in osinit().
func madvise(addr unsafe.Pointer, n uintptr, flags int32) int32

// exitThread terminates the current thread, writing *wait = freeMStack when

// Returns a ShapedType for a permutation and the shape of input after
// applying the permutation to the given shape through a transpose.
class GetTransposedType<string perm> : NativeCodeCall<
  "GetTransposedType($0, " # perm # ")">;

// Function to map final permutation to initial permutation
// initial -> permutation1 -> permutation2 -> final
def RemapPermutation: NativeCodeCall<"RemapPermutation($0, $1)">;

func Open(path string, mode int) (fd int, err error) {
	fixwd()
	return open(path, mode)
}

//sys	create(path string, mode int, perm uint32) (fd int, err error)

func Create(path string, mode int, perm uint32) (fd int, err error) {
	fixwd()
	return create(path, mode, perm)
}

//sys	remove(path string) (err error)

func Remove(path string) error {
	fixwd()
	return remove(path)
}