import (
	"encoding/gob"
	"fmt"
	"os"
)

func main() {
	var err error
	file := os.Stdin
	if len(os.Args) > 1 {
		file, err = os.Open(os.Args[1])
		if err != nil {
			fmt.Fprintf(os.Stderr, "dump: %s\n", err)
			os.Exit(1)
		}
		defer file.Close()
	}
	gob.Debug(file)

Jens Frederich <******@****.***> 1413343498 -0400

// Additional parameters that control the debug behavior of the Converter.
//
// Next ID: 9
message DebugOptions {
  // If not empty, dumps MLIR to the specified directory. The initial state of
  // the MLIR after import will be dumped at the beginning of each pass manager
  // run. Additionally, MLIR will be dumped before and after each pass
  // depending on pass names and functions matched using the

	}
	return &runtime{
		context: ctx,
	}, nil
}

// Dump state for all allocated resources.
func (i *runtime) Dump(ctx resource.Context) {
	i.DumpCustom(ctx, true)
}

// DumpCustom provides custom control over how the global scope is dumped.
func (i *runtime) DumpCustom(ctx resource.Context, recursive bool) {
	i.context.globalScope.dump(ctx, recursive)
}

// suiteContext returns the suiteContext.

		fmt.Fprintf(os.Stderr, "  \teach function.\n")
	case debugDumpMode:
		fmt.Fprintf(os.Stderr, "  go tool covdata debugdump [flags] -i=dir1,dir2\n\n")
		fmt.Fprintf(os.Stderr, "  \treads coverage data from dir1+dir2 and dumps\n")
		fmt.Fprintf(os.Stderr, "  \tcontents in human-readable form to stdout, for\n")
		fmt.Fprintf(os.Stderr, "  \tdebugging purposes.\n")
	default:
		panic("unexpected")
	}
	Exit(2)
}

	}()
	s.mu.Lock()
	defer s.mu.Unlock()
	if recursive {
		for _, c := range s.children {
			c.dump(ctx, recursive)
		}
	}
	wg := sync.WaitGroup{}
	for _, c := range s.resources {
		if d, ok := c.(resource.Dumper); ok {
			d := d
			wg.Add(1)
			go func() {
				d.Dump(ctx)
				wg.Done()
			}()
		}
	}
	wg.Wait()

func (d *CacheDumper) dumpNodes(logger klog.Logger) {
	dump := d.cache.Dump()
	nodeInfos := make([]string, 0, len(dump.Nodes))
	for name, nodeInfo := range dump.Nodes {
		nodeInfos = append(nodeInfos, d.printNodeInfo(name, nodeInfo))
	}
	// Extra blank line added between node entries for readability.
	logger.Info("Dump of cached NodeInfo", "nodes", strings.Join(nodeInfos, "\n\n"))
}

// in the sponge "Output Files" by looking up the environment to infer
// the directory path.
// If the provided path is the string kCrashReproducerStdErr, the data is
// dumped into the stderr.
// If the provided path is the string kCrashReproducerCrashAnalysis, the data
// is dumped to the crash analysis system. Note, environment var
// `MLIR_CRASH_REPRODUCER_DIRECTORY` can be used to override
// kCrashReproducerCrashAnalysis settings.

    wait
  fi
}

# Dumps logs from nodes in the cluster. Linux nodes to dump logs from can be
# specified via $1 or $use_custom_instance_list. If not specified then the nodes
# to dump logs for will be detected using detect-node-names(); if Windows nodes
# are present then they will be detected and their logs will be dumped too.
function dump_nodes() {
  local node_names=()

// RUN: tf-quant-opt %s -split-input-file -quant-add-dump-tensor-op='debugger_type=whole_model' | FileCheck --check-prefix=WholeModel %s
// RUN: tf-quant-opt %s -split-input-file -quant-add-dump-tensor-op='debugger_type=int_per_layer' | FileCheck --check-prefix=IntPerLayer %s
// RUN: tf-quant-opt %s -split-input-file -quant-add-dump-tensor-op='debugger_type=float_per_layer' | FileCheck --check-prefix=FloatPerLayer %s

module {