You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: futimens.go
    path of file: ./repos/sliver/vendor/github.com/tetratelabs/wazero/internal/sysfs
    
    the code of the file until where you have to start completion: package sysfs

import (
	"syscall"
	"time"
	"unsafe"

	experimentalsys "github.com/tetratelabs/wazero/experimental/sys"
	"github.com/tetratelabs/wazero/sys"
)

const (
	// UTIME_NOW is a special syscall.Timespec NSec value used to set the
	// file's timestamp to a value close to, but not greater than the current
	// system time.
	UTIME_NOW = _UTIME_NOW

	// UTIME_OMIT is a special syscall.Timespec NSec value used to avoid
	// setting the file's timestamp.
	UTIME_OMIT = _UTIME_OMIT
)

// Utimens set file access and modification times on a path resolved to the
// current working directory, at nanosecond precision.
//
// # Parameters
//
// The `times` parameter includes the access and modification timestamps to
// assign. Special syscall.Timespec NSec values UTIME_NOW and UTIME_OMIT may be
// specified instead of real timestamps. A nil `times` parameter behaves the
// same as if both were set to UTIME_NOW. If the path is a symbolic link, the
// target of expanding that link is updated.
//
// # Errors
//
// A zero sys.Errno is su
    
func utimensPortable(path string, times *[2]syscall.Timespec) error { //nolint:unused
	// Handle when both inputs are current system time.
	if times == nil || times[0].Nsec == UTIME_NOW && times[1].Nsec == UTIME_NOW {
		ts := nowTimespec()
		return syscall.UtimesNano(path, []syscall.Timespec{ts, ts})
	}

	// When both inputs are omitted, there is nothing to change.
	if times[0].Nsec == UTIME_OMIT && times[1].Nsec == UTIME_OMIT {
		return nil
	}

	// Handle when neither input are special values
	if times[0].Nsec != UTIME_NOW && times[1].Nsec != UTIME_NOW &&
		times[0].Nsec != UTIME_OMIT && times[1].Nsec != UTIME_OMIT {
		return syscall.UtimesNano(path, times[:])
	}

	// Now, either atim or mtim is a special value, but not both.

	// Now, either one of the inputs is a special value, or neither. This means
	// we don't have a risk of re-reading the clock or re-doing stat.
	if atim, err := normalizeTimespec(path, times, 0); err != 0 {
		return err
	} else if mtim, err := normalizeTimespec(path, times, 1); err != 0 {
		return err
	} else {
		return syscall.UtimesNano(path, []syscall.Timespec{atim, mtim})
	}
}