// via reflect.

package main

import (
	"reflect"
	"runtime"
	"unsafe"
)

var badPtr uintptr

var sink []byte

func init() {
	// Allocate large enough to use largeAlloc.
	b := make([]byte, 1<<16-1)
	sink = b // force heap allocation
	//  Any space between the object and the end of page is invalid to point to.
	badPtr = uintptr(unsafe.Pointer(&b[len(b)-1])) + 1
}

    tf_executor.NextIteration.sink and tf_executor.NextIteration.source because
    NextIteration is a back-edge in Tensorflow graph, which would form a data
    flow cycle if expressed naively in a basic block.
    tf_executor.NextIteration.source takes no input but returns results while
    tf_executor.NextIteration.sink takes input but doesn't return anything. When

kind: Sidecar
metadata:
  name: sidecar-with-egressproxy
  namespace: app
spec:
  outboundTrafficPolicy:
    mode: ALLOW_ANY
    egressProxy:
      host: foo.bar
      subset: shiny
      port:
        number: 5000
  egress:
  - hosts:
    - "*/*"
`,
	})
	proxy := s.SetupProxy(&model.Proxy{
		ConfigNamespace: "app",
	})

	listeners := s.Listeners(proxy)

                    properties:
                      timeoutSeconds:
                        description: timeoutSeconds specifies the seconds of ClientIP
                          type session sticky time. The value must be >0 && <=86400(for
                          1 day) if ServiceAffinity == "ClientIP". Default value is
                          10800(for 3 hours).
                        type: integer

    when (mapping.type) {
      TYPE_IGNORED -> Unit
      TYPE_MAPPED, TYPE_DISALLOWED_STD3_MAPPED -> {
        sink.write(mapping.mappedTo)
      }

      TYPE_DEVIATION, TYPE_DISALLOWED_STD3_VALID, TYPE_VALID -> {
        sink.writeUtf8CodePoint(codePoint)
      }

      TYPE_DISALLOWED -> {
        sink.writeUtf8CodePoint(codePoint)
        result = false
      }
    }

    return result
  }
}

          .post(
            object : RequestBody() {
              override fun contentType() = null

              override fun writeTo(sink: BufferedSink) {
                for (i in 0..9) {
                  sink.writeByte(0)
                  sink.flush()
                  sleep(100)
                }
                fail("Expected connection to be closed")
              }
            },
          )

import (
	"fmt"

	"example.com/pgo/devirtualize/mult.pkg"
)

var sink int

type Adder interface {
	Add(a, b int) int
}

type Add struct{}

func (Add) Add(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return a + b
}

type Sub struct{}

func (Sub) Add(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return a - b
}

// ExerciseIface calls mostly a1 and m1.

// the value `checkpoint_path`.
// Also adds SessionInitializer op.
absl::Status AddSessionInitializerAndInlineCheckpoint(
    ModuleOp module, absl::string_view checkpoint_path);

// Creates a pass that sinks SavedModel asset filenames to constants.
std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>> CreateAssetSinkingPass(
    llvm::StringRef saved_model_dir);

}  // namespace tf_saved_model
}  // namespace mlir

// See https://fetch.spec.whatwg.org/#readablestream for more information.
type streamReader struct {
	pending []byte
	stream  js.Value
	err     error // sticky read error
}

func (r *streamReader) Read(p []byte) (n int, err error) {
	if r.err != nil {
		return 0, r.err
	}
	if len(r.pending) == 0 {
		var (
			bCh   = make(chan []byte, 1)

   *
   * @param sink the output byte array
   * @param offset the offset into the array at which to start writing
   * @param value the value to write
   */
  static void store64(byte[] sink, int offset, long value) {
    // We don't want to assert in production code.
    assert offset >= 0 && offset + 8 <= sink.length;
    // Delegates to the fast (unsafe)version or the fallback.