testBuffer_writeTo(t, size, name == "Copy")
			})
		}
	}
}

func testBuffer_writeTo(t *testing.T, chunks int, useCopy bool) {
	oldHook := poll.TestHookDidWritev
	defer func() { poll.TestHookDidWritev = oldHook }()
	var writeLog struct {
		sync.Mutex
		log []int
	}
	poll.TestHookDidWritev = func(size int) {
		writeLog.Lock()
		writeLog.log = append(writeLog.log, size)

			if _, ok := s.conns[c]; ok {
				delete(s.conns, c)
				// Keep Close from returning until the user's ConnState hook
				// (if any) finishes.
				defer s.wg.Done()
			}
		}
		if oldHook != nil {
			oldHook(c, cs)
		}
	}
}

// closeConn closes c.
// s.mu must be held.
func (s *Server) closeConn(c net.Conn) { s.closeConnChan(c, nil) }

go list asdfasdfasdf  # succeeds because of -e
go list runtime
stdout '[\\/]runtime$'

env GOFLAGS=-race OLDGOARCH=$GOARCH OLDGOOS=$GOOS GOARCH=386 GOOS=linux
! go list runtime
stderr 'race is not supported on linux/386'

env GOARCH=$OLDGOARCH GOOS=$OLDGOOS

# go env succeeds even though -f={{.Dir}} is inappropriate
go env

# bad flags are diagnosed
env GOFLAGS=-typoflag
! go list runtime

		if shortcut {
			batch[0] = []byte{1}
		} else {
			batch[0] = []byte{0}
		}

		s.storeNode(batch, h, oldRoot)
	}
	return h
}

// storeNode stores a batch and deletes the old node from cache
func (s *smt) storeNode(batch [][]byte, h, oldRoot []byte) {
	if !bytes.Equal(h, oldRoot) {
		var node hash
		copy(node[:], h)
		// record new node
		s.db.updatedMux.Lock()

            .filter(snapshot -> isAncestorASymlink(symlinkCache, new File(snapshot.getAbsolutePath())))
            .reduce(
                root,
                (oldRoot, snapshot) -> invalidator.invalidate(snapshot.getAbsolutePath(), oldRoot),
                nonCombining());
    }

    @CheckReturnValue
    private static SnapshotHierarchy removeDirectSymlinks(SnapshotHierarchy root, Invalidator invalidator) {

	goroot           string
	goextlinkenabled string
	gogcflags        string // For running built compiler
	goldflags        string
	goexperiment     string
	workdir          string
	tooldir          string
	oldgoos          string
	oldgoarch        string
	oldgocache       string
	exe              string
	defaultcc        map[string]string
	defaultcxx       map[string]string
	defaultpkgconfig string
	defaultldso      string

	} else {
		// If periodic cert refresh resulted in discovery of a new root, trigger a ROOTCA request to refresh trust anchor
		oldRoot := sc.cache.GetRoot()
		if !bytes.Equal(oldRoot, ns.RootCert) {
			cacheLog.Info("Root cert has changed, start rotating root cert")
			// We store the oldRoot only for comparison and not for serving
			sc.cache.SetRoot(ns.RootCert)
			sc.OnSecretUpdate(security.RootCertReqResourceName)
		}
	}

func get_PivotRootAddr() *(func(newroot string, oldroot string) (err error))

var PivotRoot = enter_PivotRoot

func enter_PivotRoot(newroot string, oldroot string) (err error) {
	funcref := get_PivotRootAddr()
	if funcptrtest(GetZosLibVec()+SYS___PIVOT_ROOT_A<<4, "") == 0 {
		*funcref = impl_PivotRoot
	} else {
		*funcref = error_PivotRoot
	}
	return (*funcref)(newroot, oldroot)
}

//sys	Mknod(path string, mode uint32, dev int) (err error) = SYS___MKNOD_A
//sys	Mknodat(dirfd int, path string, mode uint32, dev int) (err error) = SYS___MKNODAT_A
//sys	PivotRoot(newroot string, oldroot string) (err error) = SYS___PIVOT_ROOT_A
//sys	Pread(fd int, p []byte, offset int64) (n int, err error)
//sys	Pwrite(fd int, p []byte, offset int64) (n int, err error)

  }

  // Attempt to constant fold the operation.
  auto abstract_op = op->getRegisteredInfo();
  LogicalResult folded = failure();
  if (abstract_op) {
    folded = abstract_op->foldHook(op, constant_operands, fold_results);
  }
  // Attempt dialect fallback if op's fold hook failed.
  if (failed(folded)) {
    Dialect* dialect = op->getDialect();
    if (!dialect) return failure();