return errno
	}

	return nil
}

func Openat(dirfd int, path string, flags int, perm uint32) (int, error) {
	p, err := syscall.BytePtrFromString(path)
	if err != nil {
		return 0, err
	}

	fd, _, errno := syscall.Syscall6(openatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags), uintptr(perm), 0, 0)
	if errno != 0 {
		return 0, errno
	}

	return int(fd), nil

def ReorderTransposeDequantQuant :
      Pat<(TF_TransposeOp:$old_value
              (TFL_DequantizeOp (TFL_QuantizeOp $input, $qtype)), $perm),
          (TFL_DequantizeOp (TFL_QuantizeOp
                                (TF_TransposeOp $input, $perm),
                                (UpdateShapeWithAxis<-1> $qtype, $old_value))),
          [(CanUpdateShapeWithAxis<-1> $qtype, $old_value)]>;

	VX     d3, d1, d1  \
	VERLLF $7, a1, a1  \
	VERLLF $7, b1, b1  \
	VERLLF $7, c1, c1  \
	VERLLF $7, d1, d1

#define PERMUTE(mask, v0, v1, v2, v3) \
	VPERM v0, v0, mask, v0 \
	VPERM v1, v1, mask, v1 \
	VPERM v2, v2, mask, v2 \
	VPERM v3, v3, mask, v3

#define ADDV(x, v0, v1, v2, v3) \
	VAF x, v0, v0 \
	VAF x, v1, v1 \
	VAF x, v2, v2 \
	VAF x, v3, v3

	Removes    []string
	Files      map[string][]*os.FileInfo
	FilesLock  sync.RWMutex
}

// Mkdir is a fake call that just returns nil.
func (f *FakeOS) MkdirAll(path string, perm os.FileMode) error {
	if f.MkdirAllFn != nil {
		return f.MkdirAllFn(path, perm)
	}
	return nil
}

// Symlink is a fake call that just returns nil.
func (f *FakeOS) Symlink(oldname string, newname string) error {
	if f.SymlinkFn != nil {

// license that can be found in the LICENSE file.

//go:build wasip1

package os

import (
	"internal/poll"
	"syscall"
)

func open(filePath string, flag int, perm uint32) (int, poll.SysFile, error) {
	if filePath == "" {
		return -1, poll.SysFile{}, syscall.EINVAL
	}
	absPath := filePath
	// os.(*File).Chdir is emulated by setting the working directory to the

			// See issue #42334.
			//
			// If the file is on NFS, we can see EOPNOTSUPP.
			// See issue #40731.
			//
			// If the process is running inside a Docker container,
			// we might see EPERM instead of ENOSYS. See issue
			// #40893. Since EPERM might also be a legitimate error,
			// don't mark copy_file_range(2) as unsupported.
			return 0, false, nil
		case nil:
			if n == 0 {
				// If we did not read any bytes at all,

          tpose_arg_rank == 0)) {
      return failure();
    }

    auto perm = llvm::dyn_cast_or_null<arith::ConstantOp>(
        tpose_arg.getPerm().getDefiningOp());
    if (!perm) {
      return failure();
    }
    auto perm_value =
        llvm::dyn_cast<DenseElementsAttr>(perm.getValue()).getValues<int32_t>();
    llvm::SmallVector<int32_t> perm_arr(perm_value.begin(), perm_value.end());

  "CreateCastToInt32($0, $_loc, $_builder)">;
// TODO: b/304003568 - Add TF_TransposeOp folding logic to tflite.
def LegalizeTranspose : Pat<(MHLO_TransposeOp $arg, $perm),
                            (TFL_TransposeOp $arg,
                            (CreateTFLCastToInt32Op (TFL_ConstOp $perm)))>;


def ConvertDotGeneralOp : NativeCodeCall<"ConvertDotGeneralOp($_builder, "
                                               "$0.getDefiningOp())">;

							<mapper>
								<type>perm</type>
								<user>${packaging.fess.user}</user>
								<group>${packaging.fess.group}</group>
							</mapper>
						</data>
						<data>
							<type>directory</type>
							<src>${project.build.directory}/fess/WEB-INF/classes/org/codelibs/fess/tomcat</src>
							<mapper>
								<type>perm</type>

		 *
		 * Linux will still error if we ask for user attributes on a file that
		 * we don't have read permissions on, so don't ignore those errors
		 */
		if e != nil {
			if e == EPERM && nsid != EXTATTR_NAMESPACE_USER {
				continue
			}
			return s, e
		}

		s += stmp
		pos = s
		if pos > destsiz {
			pos = destsiz
		}
	}

	return s, nil
}