type t1 int
type t2 int
type t3 int

func f1(*t2, x t3)	// ERROR "named"
func f2(t1, *t2, x t3)	// ERROR "named"
func f3() (x int, *string)	// ERROR "named"

  let arguments = (ins
    F32Tensor:$inputs,
    F32Attr:$min,
    F32Attr:$max,
    // The bitwidth of the quantization; between 2 and 16, inclusive.
    I64Attr:$num_bits,
    // Quantization range starts from 0 or 1; starts from 1 if true.
    DefaultValuedOptionalAttr<BoolAttr, "false">:$narrow_range,
    // The sign of the quantization.
    DefaultValuedOptionalAttr<BoolAttr, "false">:$is_signed
  );

  let results = (outs

				l.cacheEnd = tx[i+1].when
			} else if l.extend != "" {
				// If we're at the end of the known zone transitions,
				// try the extend string.
				if name, offset, estart, eend, isDST, ok := tzset(l.extend, l.cacheStart, sec); ok {
					l.cacheStart = estart
					l.cacheEnd = eend
					// Find the zone that is returned by tzset to avoid allocation if possible.
					if zoneIdx := findZone(l.zone, name, offset, isDST); zoneIdx != -1 {

     */
    void runAsUnmanagedWorkerThread(Runnable action);

    /**
     * Starts a new lease for the current thread. Marks the reservation of a lease. Blocks until a lease is available.
     *

// cancelGlobalContext can be used to indicate server shutdown.
var GlobalContext, cancelGlobalContext = context.WithCancel(context.Background())

// restartProcess starts a new process passing it the active fd's. It
// doesn't fork, but starts a new process using the same environment and
// arguments as when it was originally started. This allows for a newly
// deployed binary to be started. It returns the pid of the newly started

// factor, with sliding = false (meaning the timer for period starts at the same
// time as the function starts).
func NonSlidingUntil(f func(), period time.Duration, stopCh <-chan struct{}) {
	JitterUntil(f, period, 0.0, false, stopCh)
}

// NonSlidingUntilWithContext loops until context is done, running f every
// period.
//

#     ; beforeUpdateMap = map:{
#         ; UPDATE_DATETIME   = $$AccessContext$$.getAccessLocalDateTimeOnThread()
#         ; UPDATE_USER       = $$AccessContext$$.getAccessUserOnThread()
#     }
# }
#
# *The line that starts with '#' means comment-out.
#
map:{
    #; commonColumnMap = map:{
    #    ; REGISTER_DATETIME=TIMESTAMP ; REGISTER_USER=VARCHAR
    #    ; UPDATE_DATETIME=TIMESTAMP   ; UPDATE_USER=VARCHAR
    #}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that the implementation catches nil ptr indirection
// in a large address space.

// Address space starts at 1<<32 on AIX and on darwin/arm64 and on windows/arm64, so dummy is too far.
//go:build !aix && (!darwin || !arm64) && (!windows || !arm64)

package main

import "unsafe"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import "C"

import (
	"fmt"
	"os"
	"runtime"
)

// RunGoroutines starts some goroutines that don't do anything.
// The idea is to get some threads going, so that a signal will be delivered
// to a thread started by Go.
//
//export RunGoroutines
func RunGoroutines() {
	for i := 0; i < 4; i++ {

)

// HeaderString returns the toolchain configuration string written in
// Go object headers. This string ensures we don't attempt to import
// or link object files that are incompatible with each other. This
// string always starts with "go object ".
func HeaderString() string {
	archExtra := ""
	if k, v := buildcfg.GOGOARCH(); k != "" && v != "" {
		archExtra = " " + k + "=" + v
	}
	return fmt.Sprintf("go object %s %s %s%s X:%s\n",