when (filePropertyType) {
                    OutputFilePropertyType.DIRECTORY -> dir(pack(propertyValue))
                    OutputFilePropertyType.DIRECTORIES -> dirs(pack(propertyValue))
                    OutputFilePropertyType.FILE -> file(pack(propertyValue))
                    OutputFilePropertyType.FILES -> files(pack(propertyValue))
                }
            }.run {
                withPropertyName(propertyName)

  %178 = "tf.Pack"(%7, %177) {axis = 0 : i64, device = ""} : (tensor<i32>, tensor<i32>) -> tensor<2xi32>
  %179 = "tf.Tile"(%115, %178) {device = ""} : (tensor<?x1xi64>, tensor<2xi32>) -> tensor<?x?xi64>
  %180 = "tf.Mul"(%177, %118) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i32>
  %181 = "tf.Pack"(%180) {axis = 0 : i64, device = ""} : (tensor<i32>) -> tensor<1xi32>

func.func @pack(%arg0: tensor<1xf32>, %arg1: tensor<1xf32>) -> tensor<2x1xf32> {
  %0 = "tfl.pack"(%arg0, %arg1) {axis = 0 : i32, values_count = 2 : i32} : (tensor<1xf32>, tensor<1xf32>) -> tensor<2x1xf32>
  func.return %0 : tensor<2x1xf32>
}

// CHECK:   func @pack(%[[VAL_0:.*]]: tensor<1xf32>, %[[VAL_1:.*]]: tensor<1xf32>) -> tensor<2x1xf32> {

        this.delegate = delegate;
    }

    @Override
    public PackResult pack(CacheableEntity entity, Map<String, ? extends FileSystemSnapshot> snapshots, OutputStream output, OriginWriter writeOrigin) throws IOException {
        try (GZIPOutputStream gzipOutput = new GZIPOutputStream(output)) {
            return delegate.pack(entity, snapshots, gzipOutput, writeOrigin);
        }
    }

    @Override

    private final Packer delegate;

    public SnappyPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override
            public OutputStream openOutput() throws IOException {

    private final Packer delegate;

    public SnappyDainPacker(Packer delegate) {
        this.delegate = delegate;
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        delegate.pack(inputs, new DelegatingDataTarget(output) {
            @Override
            public OutputStream openOutput() throws IOException {

        packer.pack(inputs, target);
        DataSource source = target.toSource();
        System.out.printf(">>> %s is %d bytes long (uncompressed length: %d, compression ratio: %,.2f%%)%n", name, source.getLength(), sumLength, (double) source.getLength() / sumLength);
        return source;
    }

    @Benchmark
    public void pack() throws IOException {

    protected FilePermissionAccess createFilePermissionAccess() {
        Mock(FilePermissionAccess)
    }

    @Override
    protected Deleter createDeleter() {
        Mock(Deleter)
    }

    def "can pack single file with file mode #mode"() {
        def sourceOutputFile = Spy(File, constructorArgs: [temporaryFolder.file("source.txt").absolutePath]) as File
        sourceOutputFile << "output"

                                     Value &padding, int num_dims = 4);

// Given value that is in 8bit type, but holds 4bit data in unpacked format,
// pack to nibble format along pack_dim.
// If the pack_dim size is odd, add 1-size 0 padding and then pack.
Value PackOperand(OpBuilder &builder, Location loc, Value value, int pack_dim);

}  // namespace mlir::quant

        if (!local.canStore() && !remote.canStore()) {
            return;
        }
        tmp.withTempFile(((BuildCacheKeyInternal) key).getHashCodeInternal(), file -> {
            packExecutor.pack(file, key, entity, snapshots, executionTime);
            remote.maybeStore(key, file);
            local.maybeStore(key, file);
        });
    }

    @Override
    public void close() throws IOException {