Esempio n. 1
0
/****************************************
 * API - write user data to a mailbox
 * IN:
 *  mb_id  - handle for the mailbox
 *  offset - offset within the mailbox from which to start writing
 *  size   - size of the data
 *  data   - data
 ****************************************/
mb_error_t
mb_write(mb_id_t mb_id, void* data, off_t offset, size_t size)
{
    mb_handle_t*      mbhdl;
    mb_hdr_t*         mbhdr;
    unsigned char*    taddr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;

    if (offset + size + sizeof(mb_hdr_t) > mbhdr->ttSize) {
        _set_errno(ENOSPC);
        return (MB_ERROR);
    }
    if (lockf(mbhdl->fd, F_LOCK, 0) == -1) {
        return (MB_ERROR);
    }
    taddr  = (unsigned char*) mbhdl->maddr;
    taddr += sizeof(mb_hdr_t) + offset;
    memcpy(taddr, data, size);
    (void) lockf(mbhdl->fd, F_ULOCK, 0);

    return MB_OK;
}
Esempio n. 2
0
int WRT_access(const char * const _FileName, int _AccessMode)
{
	if (!_FileName || (_AccessMode & ~0x6) != 0)
	{
		_set_errno(EINVAL);
		return -1;
	}

	try
	{
		auto file = AWait(Windows::Storage::StorageFile::GetFileFromPathAsync(ConvertString(_FileName)));

		if ((file->Attributes & Windows::Storage::FileAttributes::Directory) != Windows::Storage::FileAttributes::Directory &&
			(file->Attributes & Windows::Storage::FileAttributes::ReadOnly) == Windows::Storage::FileAttributes::ReadOnly &&
			(_AccessMode & 0x2) != 0)
		{
			throw ref new Platform::AccessDeniedException();
		}

		return 0;
	}
	catch (AccessDeniedException^ e)
	{
		_set_errno(EACCES);
		return -1;
	}
	catch (Exception^ e)
Esempio n. 3
0
/*
 * @implemented
 */
wchar_t* _ui64tow(unsigned __int64 value, wchar_t* string, int radix)
{
  wchar_t tmp[65];
  wchar_t* tp = tmp;
  long i;
  unsigned long v = value;
  wchar_t* sp;

  if (radix > 36 || radix <= 1) {
    _set_errno(EDOM);
    return 0;
  }

  while (v || tp == tmp) {
    i = v % radix;
    v = v / radix;
    if (i < 10)
      *tp++ = i+L'0';
    else
      *tp++ = i + L'a' - 10;
  }

  if (string == 0)
    string = (wchar_t*)malloc(((tp-tmp)+1)*sizeof(wchar_t));
  sp = string;

  while (tp > tmp)
    *sp++ = *--tp;
  *sp = 0;
  return string;
}
Esempio n. 4
0
size_t _wcrtomb_r(
	char *s,
	wchar_t wc,
	mbstate_t *ps)
{
  int retval = 0;
  char buf[10];

#ifdef _MB_CAPABLE
  if (ps == NULL) {
      ps = &(tls_current()->mbst);
    }
#endif

  if (s == NULL)
    retval = __WCTOMB (buf, L'\0', ps);
  else
    retval = __WCTOMB (s, wc, ps);

  if (retval == -1)
    {
      ps->__count = 0;
      _set_errno(EILSEQ);
      return (size_t)(-1);
    }
  else
    return (size_t)retval;
}
Esempio n. 5
0
/**********************************************************************
 *		__wcserror_s	(MSVCRT.@)
 */
int CDECL __wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, const MSVCRT_wchar_t* str)
{
    int err;
    static const WCHAR colonW[] = {':', ' ', '\0'};
    static const WCHAR nlW[] = {'\n', '\0'};
    size_t len;

    err = *MSVCRT__errno();
    if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;

    len = MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, NULL, 0) + 1 /* \n */;
    if (str && *str) len += lstrlenW(str) + 2 /* ': ' */;
    if (len > nc)
    {
        MSVCRT_INVALID_PMT("buffer[nc] is too small");
        _set_errno(MSVCRT_ERANGE);
        return MSVCRT_ERANGE;
    }
    if (str && *str)
    {
        lstrcpyW(buffer, str);
        lstrcatW(buffer, colonW);
    }
    else buffer[0] = '\0';
    len = lstrlenW(buffer);
    MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, buffer + len, 256 - len);
    lstrcatW(buffer, nlW);

    return 0;
}
Esempio n. 6
0
/**********************************************
 * API - set current state of a mailbox
 * IN:
 *  mb_id - handle for the mailbox
 *  state - current mailbox state
 ***********************************************/
mb_error_t
mb_setstate(mb_id_t mb_id, mb_state_t state)
{
    mb_handle_t* mbhdl;
    mb_hdr_t*    mbhdr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;

    if (lockf(mbhdl->fd, F_LOCK, 0) == -1) {
        return (MB_ERROR);
    }
    mbhdr->curState = state;
    if ((mbhdl->flags & (MB_OWNER|MB_CALLBACK)) == (MB_OWNER|MB_CALLBACK)) {
         mbhdl->flags &= ~MB_CALLBACK;
    }
    /* State changed - multicast this mailbox  */
    _mb_net_send(mbhdr);
    (void) lockf(mbhdl->fd, F_ULOCK, 0);

    return (MB_OK);
}
bool tScriptState::GetParam(CString& s, tParamType paramType, CString& dest, tParameter& param)
{
    bool bOK = FALSE;
    dest.Empty();
    while (isspace(s[0])) s.Delete(0, 1);
    switch (paramType)
    {
        case ptString:
            if ((s[0] == '\"') || s[0] == '\'')
            {
                char endchar = s[0];
                s.Delete(0, 1);
                int pos = s.Find(endchar);
                if (pos > 0)
                {
                    while (IsSuitableCharForString(s[0]) || isspace(s[0])) { dest += s[0]; s.Delete(0, 1); }
                    bOK = s[0] == endchar;
                    if (bOK)
                    {
                        s.Delete(0, 1);
                        while (isspace(dest[dest.GetLength() - 1])) dest.Delete(dest.GetLength() - 1, 1);
                    }
                }
            }
            else
            {
                while (IsSuitableCharForString(s[0])) { dest += s[0]; s.Delete(0, 1); }
            }
            bOK = !dest.IsEmpty();
            param = dest;
            break;
        case ptInteger:
            if (s[0] == '-') { dest += s[0]; s.Delete(0, 1); }
            while (isdigit(s[0])) { dest += s[0]; s.Delete(0, 1); }
            bOK = !dest.IsEmpty();
            param = dest;
            if (bOK)
            {
                char *end = NULL;
                _set_errno(0);
                int val = strtoul(dest.GetBuffer(), &end, 10);
                bOK = !errno;
                if (bOK) param = (ULONG)val;
            }
            else if (s[0] == '$')
            {
                s.Delete(0,1);
                while (IsSuitableCharForString(s[0])) { dest += s[0]; s.Delete(0, 1); }
                param.Refer(dest, QueryVariable, this);
                bOK = TRUE;
            }
            break;
        case ptNone:
            bOK = TRUE;
            break;
        default:
            break;
    }
    return bOK;
}
Esempio n. 8
0
WRT_FILE* WRT_fopen(const char * _Filename, const char * _Mode)
{
	WRT_FILE* ret;
	int err = WRT_fopen_s(&ret, _Filename, _Mode);
	_set_errno(err);
	return err ? nullptr : ret;
}
Esempio n. 9
0
int munmap(void *start, size_t length)
{
    int i, j;

    for( i = 0; i < g_curMMapInfos; i++ ) {
        if( g_mmapInfos[i].start == start )
            break;
    }
    if( i == g_curMMapInfos ) {
        _set_errno( EINVAL );
        return -1;
    }

    UnmapViewOfFile( g_mmapInfos[g_curMMapInfos].start );
    CloseHandle( g_mmapInfos[g_curMMapInfos].hMap );
    CloseHandle( g_mmapInfos[g_curMMapInfos].hFile );

    EnterCriticalSection( &cs );
    for( j = i + 1; j < g_curMMapInfos; j++ ) {
        memcpy( &g_mmapInfos[ j - 1 ], &g_mmapInfos[ j ],
                sizeof( struct mmapInfos ) );
    }
    g_curMMapInfos--;
    
    if( g_curMMapInfos == 0 ) {
        free( g_mmapInfos );
        g_mmapInfos = NULL;
        g_maxMMapInfos = 0;
    }
    LeaveCriticalSection( &cs );
    
    return 0;
}
Esempio n. 10
0
/* unlink
 * The is the ANSI C file 
 * deletion method and is shared by the 'modern' */
int unlink(
	_In_ const char *path) {
	if (path == NULL) {
		_set_errno(EINVAL);
		return EOF;
	}
	return _fval(DeletePath(path, 0));
}
Esempio n. 11
0
/*********************************************************************
 *		_wcserror_s (MSVCRT.@)
 */
int CDECL _wcserror_s(MSVCRT_wchar_t* buffer, MSVCRT_size_t nc, int err)
{
    if (!MSVCRT_CHECK_PMT(buffer != NULL) || !MSVCRT_CHECK_PMT(nc > 0))
    {
        _set_errno(MSVCRT_EINVAL);
        return MSVCRT_EINVAL;
    }
    if (err < 0 || err > MSVCRT__sys_nerr) err = MSVCRT__sys_nerr;
    MultiByteToWideChar(CP_ACP, 0, MSVCRT__sys_errlist[err], -1, buffer, nc);
    return 0;
}
Esempio n. 12
0
/* Set errno variable */
void
dirent_set_errno(
    int error)
{
#if defined(_MSC_VER)  &&  _MSC_VER >= 1400
    /* Microsoft Visual Studio 2005 and later */
    _set_errno (error);
#else
    /* Non-Microsoft compiler or older Microsoft compiler */
    errno = error;
#endif
}
Esempio n. 13
0
wint_t fgetwc(FILE *stream)
{
	StdioObject_t*  Object;
    wint_t          Result;
    int             ch;

    _lock_file(stream);
    Object = get_ioinfo(stream->_fd);
    if (Object == NULL) {
        _unlock_file(stream);
        _set_errno(EBADFD);
        return (wint_t)-1;
    }

    if ((Object->exflag & (EF_UTF8 | EF_UTF16)) || !(Object->wxflag & WX_TEXT)) {
        
        char *p;
        for (p = (char *)&Result; (wint_t *)p < &Result + 1; p++) {
            ch = fgetc(stream);
            if (ch == EOF) {
                Result = WEOF;
                break;
            }
            *p = (char)ch;
        }
    }
    else
    {
        char mbs[MB_LEN_MAX];
        int len = 0;

        ch = fgetc(stream);
        if (ch != EOF) {
            mbs[0] = (char)ch;
            if (_issjis1((unsigned char)mbs[0])) {
                ch = fgetc(stream);
                if (ch != EOF)
                {
                    mbs[1] = (char)ch;
                    len = 2;
                }
            }
            else {
                len = 1;
            }
        }

        if (!len || mbtowc((wchar_t*)&Result, mbs, len) == -1)
            Result = WEOF;
    }
    _unlock_file(stream);
    return Result;
}
Esempio n. 14
0
/*********************************************************************
 *  wcsncat_s (MSVCRT.@)
 *
 */
INT CDECL wcsncat_s(wchar_t *dst, size_t elem,
        const wchar_t *src, size_t count)
{
    size_t srclen;
    wchar_t dststart;
    INT ret = 0;

    if (!MSVCRT_CHECK_PMT(dst != NULL) || !MSVCRT_CHECK_PMT(elem > 0))
    {
#ifndef _LIBCNT_
        _set_errno(EINVAL);
#endif
        return EINVAL;
    }
    if (!MSVCRT_CHECK_PMT(src != NULL || count == 0))
        return EINVAL;
    if (count == 0)
        return 0;

    for (dststart = 0; dststart < elem; dststart++)
    {
        if (dst[dststart] == '\0')
            break;
    }
    if (dststart == elem)
    {
        MSVCRT_INVALID_PMT("dst[elem] is not NULL terminated\n", EINVAL);
        return EINVAL;
    }

    if (count == _TRUNCATE)
    {
        srclen = strlenW(src);
        if (srclen >= (elem - dststart))
        {
            srclen = elem - dststart - 1;
            ret = STRUNCATE;
        }
    }
    else
        srclen = min(strlenW(src), count);
    if (srclen < (elem - dststart))
    {
        memcpy(&dst[dststart], src, srclen*sizeof(wchar_t));
        dst[dststart+srclen] = '\0';
        return ret;
    }
    MSVCRT_INVALID_PMT("dst[elem] is too small", ERANGE);
    dst[0] = '\0';
    return ERANGE;
}
Esempio n. 15
0
/********************************************
 * API - return the data length of a mailbox
 * IN:
 *  mb_id  - handle for the mailbox
 ********************************************/
size_t
mb_len(mb_id_t mb_id)
{
    mb_handle_t*    mbhdl;
    mb_hdr_t*       mbhdr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;
    return mbhdr->ttSize - sizeof(mb_hdr_t);
}
Esempio n. 16
0
/******************************************************************
 *		_wcsupr_s (MSVCRT.@)
 *
 */
INT CDECL _wcsupr_s( wchar_t* str, size_t n )
{
  wchar_t* ptr = str;

  if (!str || !n)
  {
    if (str) *str = '\0';
    _set_errno(EINVAL);
    return EINVAL;
  }

  while (n--)
  {
    if (!*ptr) return 0;
    *ptr = toupperW(*ptr);
    ptr++;
  }

  /* MSDN claims that the function should return and set errno to
   * ERANGE, which doesn't seem to be true based on the tests. */
  *str = '\0';
  _set_errno(EINVAL);
  return EINVAL;
}
Esempio n. 17
0
/*
 * @implemented
 *
 *    _chdrive (MSVCRT.@)
 *
 * Change the current drive.
 *
 * PARAMS
 *  newdrive [I] Drive number to change to (1 = 'A', 2 = 'B', ...)
 *
 * RETURNS
 *  Success: 0. The current drive is set to newdrive.
 *  Failure: -1. errno indicates the error.
 *
 * NOTES
 *  See SetCurrentDirectoryA.
 */
int _chdrive(int newdrive)
{
  WCHAR buffer[] = L"A:";

  buffer[0] += newdrive - 1;
  if (!SetCurrentDirectoryW( buffer ))
  {
    _dosmaperr(GetLastError());
    if (newdrive <= 0)
    {
      _set_errno(EACCES);
    }
    return -1;
  }
  return 0;
}
Esempio n. 18
0
/*********************************************
 * API - get current state of a mailbox
 * IN:
 *  mb_id - handle for the mailbox
 * OUT:
 *  state - current mailbox state
 **********************************************/
mb_error_t
mb_getstate(mb_id_t mb_id, mb_state_t* state)
{
    mb_handle_t* mbhdl;
    mb_hdr_t*    mbhdr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;

    *state = mbhdr->curState;

    return (MB_OK);
}
Esempio n. 19
0
int
__statfsx64 (const char *file, struct statfsx64 *buf)
{
	char *RootDirectory = rootdir (file);
	int res = 0;
	
	if ((RootDirectory == NULL) ) {// || access (file, F_OK)) { // || (GetDriveType(RootDirectory) == DRIVE_REMOVABLE)) {
//   	fprintf(stderr, "__statfsx64: RootDirectory: %s\n", RootDirectory);
		buf = NULL;
		_set_errno(ENOENT);
		res = -1;
	}
	else
		res = __rstatfsx64 ((const char *) RootDirectory, buf);
	free (RootDirectory);
	return res;
}
Esempio n. 20
0
int
__cdecl
vfwprintf_s(FILE* file, const wchar_t *format, va_list argptr)
{
    int ret;

    if(!MSVCRT_CHECK_PMT( file != NULL)) {
        _set_errno(EINVAL);
        return -1;
    }

    _lock_file(file);
    ret = wstreamout(file, format, argptr);
    _unlock_file(file);

    return ret;
}
Esempio n. 21
0
/***********************************
 * API - set requested state
 * IN:
 *  mb_id - handle for the mailbox
 *  state - current mailbox state
 ***********************************/
mb_error_t
mb_setexpectedstate(mb_id_t mb_id, mb_state_t state)
{
    mb_handle_t* mbhdl;
    mb_hdr_t*    mbhdr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;

    mbhdr->rqstState = state;

    return (MB_OK);
}
Esempio n. 22
0
int lstat(const char *path, struct stat *buffer)
{
    WIN32_FILE_ATTRIBUTE_DATA fdata;

    if (GetFileAttributesEx(path, GetFileExInfoStandard, &fdata))
    {
        int fMode = S_IREAD;
        if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            fMode |= S_IFDIR;
        else
            fMode |= S_IFREG;
        if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
            fMode |= S_IWRITE;

        buffer->st_ino = 0;
        buffer->st_gid = 0;
        buffer->st_uid = 0;
        buffer->st_nlink = 1;
        buffer->st_mode = fMode;
        buffer->st_size = fdata.nFileSizeLow;
        buffer->st_dev = buffer->st_rdev = 0;
        buffer->st_atime = filetime_to_time_t(&fdata.ftLastAccessTime);
        buffer->st_mtime = filetime_to_time_t(&fdata.ftLastWriteTime);
        buffer->st_ctime = filetime_to_time_t(&fdata.ftCreationTime);

        if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
        {
            WIN32_FIND_DATA find;
            HANDLE handle = FindFirstFile(path, &find);
            if (handle != INVALID_HANDLE_VALUE)
            {
                if ((find.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
                        (find.dwReserved0 == IO_REPARSE_TAG_SYMLINK))
                {
                    buffer->st_mode = S_IFLNK;
                }
            }
        }
        _set_errno(0);
        return 0;
    }

    errno = winErrorToPosix(GetLastError());
    return -1;
}
Esempio n. 23
0
/*
 * INTERNAL
 */
int access_dirT(const _TCHAR *_path)
{
    DWORD Attributes = GetFileAttributes(_path);
    TRACE(MK_STR(is_dirT)"('%"sT"')\n", _path);

    if (Attributes == (DWORD)-1) {
         _dosmaperr(GetLastError());
        return -1;
    }

    if ((Attributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY)
    {
      _set_errno(EACCES);
      return -1;
    }

   return 0;
}
Esempio n. 24
0
mb_error_t
mb_gettimestamp(mb_id_t mb_id,
                struct timeval *timestamp)
{
    mb_handle_t* mbhdl;
    mb_hdr_t*    mbhdr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;

    timestamp->tv_sec = mbhdr->tmStamp;
    timestamp->tv_usec = 0;

    return (MB_OK);
}
Esempio n. 25
0
File: ftp.c Progetto: 20uf/php-src
/* {{{ data_available
 */
int
data_available(ftpbuf_t *ftp, php_socket_t s)
{
	int		n;

	n = php_pollfd_for_ms(s, PHP_POLLREADABLE, 1000);
	if (n < 1) {
#ifdef PHP_WIN32
		if (n == 0) {
			_set_errno(ETIMEDOUT);
		}
#elif !(defined(NETWARE) && defined(USE_WINSOCK))
		if (n == 0) {
			errno = ETIMEDOUT;
		}
#endif
		return 0;
	}

	return 1;
}
Esempio n. 26
0
/*********************************************************************
 *		wcstok_s  (MSVCRT.@)
 */
wchar_t * CDECL wcstok_s( wchar_t *str, const wchar_t *delim,
                                 wchar_t **next_token )
{
    wchar_t *ret;

    if (!MSVCRT_CHECK_PMT(delim != NULL) || !MSVCRT_CHECK_PMT(next_token != NULL) ||
        !MSVCRT_CHECK_PMT(str != NULL || *next_token != NULL))
    {
        _set_errno(EINVAL);
        return NULL;
    }
    if (!str) str = *next_token;

    while (*str && strchrW( delim, *str )) str++;
    if (!*str) return NULL;
    ret = str++;
    while (*str && !strchrW( delim, *str )) str++;
    if (*str) *str++ = 0;
    *next_token = str;
    return ret;
}
Esempio n. 27
0
/********************************************
 * API - multicast the mailbox
 * IN:
 *  mb_id  - handle for the mailbox
 ********************************************/
mb_error_t
mb_broadcast(mb_id_t mb_id)
{
    mb_handle_t* mbhdl;
    mb_hdr_t*    mbhdr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;

    if (lockf(mbhdl->fd, F_LOCK, 0) == -1) {
        return (MB_ERROR);
    }
    _mb_net_send(mbhdr);
    (void) lockf(mbhdl->fd, F_ULOCK, 0);

    return (MB_OK);
}
Esempio n. 28
0
/* {{{ data_writeable
 */
int
data_writeable(ftpbuf_t *ftp, php_socket_t s)
{
	int		n;

	n = php_pollfd_for_ms(s, POLLOUT, 1000);
	if (n < 1) {
#ifdef PHP_WIN32
		if (n == 0) {
			_set_errno(ETIMEDOUT);
		}
#else
		if (n == 0) {
			errno = ETIMEDOUT;
		}
#endif
		return 0;
	}

	return 1;
}
Esempio n. 29
0
/* {{{ my_accept
 */
int
my_accept(ftpbuf_t *ftp, php_socket_t s, struct sockaddr *addr, socklen_t *addrlen)
{
	int		n;

	n = php_pollfd_for_ms(s, PHP_POLLREADABLE, ftp->timeout_sec * 1000);
	if (n < 1) {
#ifdef PHP_WIN32
		if (n == 0) {
			_set_errno(ETIMEDOUT);
		}
#else
		if (n == 0) {
			errno = ETIMEDOUT;
		}
#endif
		return -1;
	}

	return accept(s, addr, addrlen);
}
Esempio n. 30
0
/***********************************
 * API - Close a mailbox
 * IN:
 *  mb_id - handle for the mailbox
 ***********************************/
mb_error_t
mb_close(mb_id_t mb_id)
{
    mb_handle_t* mbhdl;
    mb_hdr_t*    mbhdr;

    mbhdl = (mb_handle_t*) mb_id;
    if (MB_BAD(mbhdl)) {
        _set_errno(EINVAL);
        return (MB_ERROR);
    }
    if (lockf(mbhdl->fd, F_LOCK, 0) == -1) {
        return (MB_ERROR);
    }
    mbhdr = (mb_hdr_t*) mbhdl->maddr;
    munmap(mbhdl->maddr, mbhdr->ttSize);
    mbhdl->valid = 0;
    close(mbhdl->fd);
    free(mbhdl);

    return (MB_OK);
}