for _, lpath := range inst.LibPaths {
		spath := filepath.Join(lpath, "go", inst.GccVersion)
		fi, err := os.Stat(spath)
		if err != nil || !fi.IsDir() {
			continue
		}
		paths = append(paths, spath)

		spath = filepath.Join(spath, inst.TargetTriple)
		fi, err = os.Stat(spath)
		if err != nil || !fi.IsDir() {
			continue
		}
		paths = append(paths, spath)
	}

//go:cgo_import_dynamic rename rename ""
//go:cgo_import_dynamic sched_yield sched_yield ""
//go:cgo_import_dynamic setrlimit setrlimit ""
//go:cgo_import_dynamic sigaction sigaction ""
//go:cgo_import_dynamic stat$INODE64 stat$INODE64 ""
//go:cgo_import_dynamic sysconf sysconf ""
//go:cgo_import_dynamic sysctl sysctl ""
//go:cgo_import_dynamic sysctlbyname sysctlbyname ""
//go:cgo_import_dynamic task_info task_info ""

//go:cgo_import_dynamic rename rename ""
//go:cgo_import_dynamic sched_yield sched_yield ""
//go:cgo_import_dynamic setrlimit setrlimit ""
//go:cgo_import_dynamic sigaction sigaction ""
//go:cgo_import_dynamic stat stat ""
//go:cgo_import_dynamic sysconf sysconf ""
//go:cgo_import_dynamic sysctl sysctl ""
//go:cgo_import_dynamic sysctlbyname sysctlbyname ""
//go:cgo_import_dynamic task_info task_info ""

func copyFile(source, dest string) error {
	sf, err := os.Open(source)
	if err != nil {
		return fmt.Errorf("unable to open source file [%s]: %q", source, err)
	}
	defer sf.Close()
	fi, err := sf.Stat()
	if err != nil {
		return fmt.Errorf("unable to stat source file [%s]: %q", source, err)
	}

	dir := filepath.Dir(dest)
	if err := os.MkdirAll(dir, 0755); err != nil {
		return fmt.Errorf("unable to create directory [%s]: %q", dir, err)
	}

    private final AtomicBoolean warned = new AtomicBoolean();
    private final FallbackStat stat = new FallbackStat();
    private final EmptyChmod chmod = new EmptyChmod();

    @Override
    public int getUnixMode(File f) throws IOException {
        maybeWarn();
        return stat.getUnixMode(f);
    }

    @Override
    public void chmod(File file, int mode) throws Exception {
        maybeWarn();

	if [ $loop_count -eq 100 ]; then
		break
	fi
	echo "Hello World" | ./mc pipe sitea/bucket/obj$loop_count
	./mc rm sitea/bucket/obj$loop_count
	RESULT=$({ ./mc stat sitea/bucket/obj$loop_count; } 2>&1)
	if [[ ${RESULT} != *"Object does not exist"* ]]; then
		echo "BUG: stat should fail. succeeded."
		exit_1
	fi
	loop_count=$((loop_count + 1))
done

//sys	Utime(path string, buf *Utimbuf) (err error)
//sys	utimes(path string, times *[2]Timeval) (err error)

//sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
//sys	Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
//sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
//sys	EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)

func Fstatfs(fd int, buf *Statfs_t) (err error) {

	})

	if err != nil {
		stat, ok := status.FromError(err)
		if ok {
			switch stat.Code() {
			case codes.Unimplemented:
				klog.V(4).ErrorS(err, "server does not implement the grpc health protocol (grpc.health.v1.Health)", "addr", addr, "service", service)
				return probe.Failure, fmt.Sprintf("error: this server does not implement the grpc health protocol (grpc.health.v1.Health): %s", stat.Message()), nil
			case codes.DeadlineExceeded:

	}
	f, err := os.CreateTemp("", "heapdumptest")
	if err != nil {
		t.Fatalf("TempFile failed: %v", err)
	}
	defer os.Remove(f.Name())
	defer f.Close()
	WriteHeapDump(f.Fd())
	fi, err := f.Stat()
	if err != nil {
		t.Fatalf("Stat failed: %v", err)
	}
	const minSize = 1
	if size := fi.Size(); size < minSize {
		t.Fatalf("Heap dump size %d bytes, expected at least %d bytes", size, minSize)
	}
}

type Obj struct {

The [Stat] function now sets the [ModeSocket] bit for
files that are Unix sockets on Windows. These files are identified