IsInf 1
 IsNan 40
 L2Loss 40
 LogicalOr 1
 Max 41
 Minimum 1
 Mul 82
 Pack 3
 Reciprocal 2
 Reshape 2
 ReverseSequence 1
 Sqrt 1
 Sum 1
 Transpose 3
cluster 1 size 86
 BroadcastGradientArgs 1
 Cast 5
 ConcatV2 1
 Const 30
 ExpandDims 3
 Less 1
 Mean 2
 Minimum 1
 Mul 3
 Pack 2
 Pad 1
 Range 1
 RealDiv 1
 Reshape 8
 Shape 7
 Size 1
 Slice 2

public class ZipPacker implements Packer {

    private final byte[] buffer;

    public ZipPacker(int bufferSizeInKBytes) {
        this.buffer = new byte[bufferSizeInKBytes];
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        ZipOutputStream zipOutput = new ZipOutputStream(output.openOutput());
        for (DataSource input : inputs) {

 * limitations under the License.
 */

package org.gradle.caching.internal.tasks;

import java.io.IOException;
import java.util.List;

interface Packer {
    void pack(List<DataSource> inputs, DataTarget output) throws IOException;
    void unpack(DataSource input, DataTargetFactory targetFactory) throws IOException;

    private final byte[] buffer;

    public JTarPacker(int bufferSizeInKBytes) {
        this.buffer = new byte[bufferSizeInKBytes * 1024];
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        TarOutputStream tarOutput = new TarOutputStream(output.openOutput());
        for (DataSource input : inputs) {
            @SuppressWarnings("OctalInteger")

  %2 = "tfl.add"(%arg0, %arg3) {fused_activation_function = "RELU6"} : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>
  %3 = "tfl.pack"(%1, %2) {axis = 0 : i32, values_count = 2 : i32} : (tensor<1xf32>, tensor<1xf32>) -> tensor<2x1xf32>
  func.return %3 : tensor<2x1xf32>
}

// CHECK: %[[CST:.*]] = arith.constant dense<1> : tensor<4xi32>

}

func NewPoolDequeue(n int) PoolDequeue {
	d := &poolDequeue{
		vals: make([]eface, n),
	}
	// For testing purposes, set the head and tail indexes close
	// to wrapping around.
	d.headTail.Store(d.pack(1<<dequeueBits-500, 1<<dequeueBits-500))
	return d
}

func (d *poolDequeue) PushHead(val any) bool {
	return d.pushHead(val)
}

func (d *poolDequeue) PopHead() (any, bool) {
	return d.popHead()
}

  %0:2 = "tfl.unpack"(%arg0) {axis = 0 : i32, num = 2 : i32} : (tensor<2x5xf32>) -> (tensor<5xf32>, tensor<5xf32>)
  %1 = "tfl.pack"(%0#0, %0#1) {axis = 0 : i32, values_count = 2 : i32} : (tensor<5xf32>, tensor<5xf32>) -> (tensor<2x5xf32>)
  func.return %1: tensor<2x5xf32>
  // CHECK-NOT: pack
  // CHECK: return %arg0 : tensor<2x5xf32>
}

// -----

// CHECK-LABEL: @RemoveRedundantPack

import org.gradle.internal.snapshot.FileSystemSnapshot;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;

public interface BuildCacheEntryPacker {
    PackResult pack(CacheableEntity entity, Map<String, ? extends FileSystemSnapshot> snapshots, OutputStream output, OriginWriter writeOrigin) throws IOException;

    class PackResult {
        private final long entries;

-- badimport/go.mod --
module example.com/badimport

go 1.16
-- badimport/badimport.go --
package badimport

import "example.net/oops"
-- badimport/syntaxerror/syntaxerror.go --
pack-age syntaxerror // sic

                                        TF_Status* status);

// Helper to un-pack `num_replicas` TFE_TensorHandles from one parallel handle.
template <std::size_t num_replicas>
void ExtractPerDeviceValues(
    TFE_Context* context, TFE_TensorHandle* input,
    std::array<TensorHandlePtr, num_replicas>* components, TF_Status* status);

// Helper to pack `num_replicas` TFE_TensorHandles into one parallel handle.
template <std::size_t num_replicas>