/*
 * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


/*
 * FUNCTIONS
 *      mlib_ImageCopy - Direct copy from one image to another.
 *
 * SYNOPSIS
 *      mlib_status mlib_ImageCopy(mlib_image       *dst,
 *                                 const mlib_image *src);
 *
 * ARGUMENT
 *      dst     pointer to output or destination image
 *      src     pointer to input or source image
 *
 * RESTRICTION
 *      src and dst must have the same size, type and number of channels.
 *      They can have 1, 2, 3 or 4 channels of MLIB_BIT, MLIB_BYTE, MLIB_SHORT,
 *      MLIB_USHORT, MLIB_INT, MLIB_FLOAT or MLIB_DOUBLE data type.
 *
 * DESCRIPTION
 *      Direct copy from one image to another
 */

#include <stdlib.h>
#include "mlib_image.h"
#include "mlib_ImageCheck.h"
#include "mlib_ImageCopy.h"

/***************************************************************/
#ifdef _MSC_VER
#pragma optimize("", off)                   /* Fix bug 4195132 */
#endif /* _MSC_VER */

/***************************************************************/
/* do not perform the coping by mlib_d64 data type for x86 */
#ifdef i386

typedef struct {
  mlib_s32 int0, int1;
} two_int;

#define TYPE_64BIT two_int

#else /* i386 */

#define TYPE_64BIT mlib_d64
#endif /* i386 */

/***************************************************************/
static void mlib_c_ImageCopy_u8(const mlib_image *src,
                                mlib_image       *dst);
static void mlib_c_ImageCopy_s16(const mlib_image *src,
                                 mlib_image       *dst);
static void mlib_c_ImageCopy_s32(const mlib_image *src,
                                 mlib_image       *dst);
static void mlib_c_ImageCopy_d64(const mlib_image *src,
                                 mlib_image       *dst);
static void mlib_c_ImageCopy_a1(const TYPE_64BIT *sp,
                                TYPE_64BIT       *dp,
                                mlib_s32         size);

/***************************************************************/
mlib_status mlib_ImageCopy(mlib_image       *dst,
                           const mlib_image *src)
{
  mlib_s32 s_offset, d_offset;
  mlib_s32 size, s_stride, d_stride;
  mlib_s32 width;                                     /* width in bytes of src and dst */
  mlib_s32 height;                                    /* height in lines of src and dst */
  mlib_u8 *sa, *da;
  mlib_s32 j;

  MLIB_IMAGE_CHECK(src);
  MLIB_IMAGE_CHECK(dst);
  MLIB_IMAGE_TYPE_EQUAL(src, dst);
  MLIB_IMAGE_CHAN_EQUAL(src, dst);
  MLIB_IMAGE_SIZE_EQUAL(src, dst);

  switch (mlib_ImageGetType(dst)) {
    case MLIB_BIT:
      width = mlib_ImageGetWidth(dst) * mlib_ImageGetChannels(dst); /* size in bits */
      height = mlib_ImageGetHeight(src);
      sa = (mlib_u8 *) mlib_ImageGetData(src);
      da = (mlib_u8 *) mlib_ImageGetData(dst);

      if (!mlib_ImageIsNotOneDvector(src) && !mlib_ImageIsNotOneDvector(dst)) {
        size = height * (width >> 3);
        if (!mlib_ImageIsNotAligned8(src) && !mlib_ImageIsNotAligned8(dst) && ((size & 7) == 0)) {

          mlib_c_ImageCopy_a1((TYPE_64BIT *) sa, (TYPE_64BIT *) da, size >> 3);
        }
        else {

          mlib_ImageCopy_na(sa, da, size);
        }
      }
      else {
        s_stride = mlib_ImageGetStride(src);
        d_stride = mlib_ImageGetStride(dst);
        s_offset = mlib_ImageGetBitOffset(src); /* in bits */
        d_offset = mlib_ImageGetBitOffset(dst); /* in bits */
        if (s_offset == d_offset) {
          for (j = 0; j < height; j++) {
            mlib_ImageCopy_bit_al(sa, da, width, s_offset);
            sa += s_stride;
            da += d_stride;
          }
        }
        else {
          for (j = 0; j < height; j++) {
            mlib_ImageCopy_bit_na(sa, da, width, s_offset, d_offset);
            sa += s_stride;
            da += d_stride;
          }
        }
      }

      break;
    case MLIB_BYTE:
      mlib_c_ImageCopy_u8(src, dst);
      break;
    case MLIB_SHORT:
    case MLIB_USHORT:
      mlib_c_ImageCopy_s16(src, dst);
      break;
    case MLIB_INT:
    case MLIB_FLOAT:
      mlib_c_ImageCopy_s32(src, dst);
      break;
    case MLIB_DOUBLE:
      mlib_c_ImageCopy_d64(src, dst);
      break;
    default:
      return MLIB_FAILURE;                  /* MLIB_BIT is not supported here */
  }

  return MLIB_SUCCESS;
}

/***************************************************************/
#define PREPAREVARS(type)                                        \
  type *psrc = (type *) mlib_ImageGetData(src);                  \
  type *pdst = (type *) mlib_ImageGetData(dst);                  \
  mlib_s32 src_height = mlib_ImageGetHeight(src);                \
  mlib_s32 src_width  = mlib_ImageGetWidth(src);                 \
  mlib_s32 src_stride = mlib_ImageGetStride(src) / sizeof(type); \
  mlib_s32 dst_stride = mlib_ImageGetStride(dst) / sizeof(type); \
  mlib_s32 chan = mlib_ImageGetChannels(dst);                    \
  mlib_s32 i, j;                                                 \
                                                                 \
  src_width *= chan;                                             \
  if (src_width == src_stride && src_width == dst_stride) {      \
    src_width *= src_height;                                     \
    src_height = 1;                                              \
  }

/***************************************************************/
#define STRIP(pd, ps, w, h, data_type) {                        \
  data_type s0, s1;                                             \
  for ( i = 0; i < h; i++ ) {                                   \
    if ((j = (w & 1)))                                              \
      pd[i * dst_stride] = ps[i * src_stride];                  \
    for (; j < w; j += 2) {                                     \
      s0 = ps[i * src_stride + j];                              \
      s1 = ps[i * src_stride + j + 1];                          \
      pd[i * dst_stride + j]   = s0;                            \
      pd[i * dst_stride + j + 1] = s1;                          \
    }                                                           \
  }                                                             \
}

/***************************************************************/
/*
 * Both bit offsets of source and distination are the same
 */

void mlib_ImageCopy_bit_al(const mlib_u8 *sa,
                           mlib_u8       *da,
                           mlib_s32      size,
                           mlib_s32      offset)
{
  mlib_s32 b_size, i, j;
  TYPE_64BIT *sp, *dp;
  mlib_u8 mask0 = 0xFF;
  mlib_u8 src, mask;

  if (size <= 0) return;

  if (size <= (8 - offset)) {
    mask = mask0 << (8 - size);
    mask >>= offset;
    src = da[0];
    da[0] = (src & (~mask)) | (sa[0] & mask);
    return;
  }

  mask = mask0 >> offset;
  src = da[0];
  da[0] = (src & (~mask)) | (sa[0] & mask);
  da++;
  sa++;
  size = size - 8 + offset;
  b_size = size >> 3;                       /* size in bytes */

  for (j = 0; (j < b_size) && (((mlib_addr) da & 7) != 0); j++)
    *da++ = *sa++;

  if ((((mlib_addr) sa ^ (mlib_addr) da) & 7) == 0) {
    sp = (TYPE_64BIT *) sa;
    dp = (TYPE_64BIT *) da;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
    for (i = 0; j <= (b_size - 8); j += 8, i++) {
      dp[i] = sp[i];
    }

    sa += i << 3;
    da += i << 3;
  }
  else {
#ifdef _NO_LONGLONG
    if ((((mlib_addr) sa ^ (mlib_addr) da) & 3) == 0) {
      mlib_u32 *pws, *pwd;

      pws = (mlib_u32 *) sa;
      pwd = (mlib_u32 *) da;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
      for (i = 0; j <= (b_size - 4); j += 4, i++) {
        pwd[i] = pws[i];
      }

      sa += i << 2;
      da += i << 2;
    }
    else {
      mlib_u32 *pws, *pwd, src0, src1;
      mlib_s32 lshift = (mlib_addr) sa & 3, rshift;

      pwd = (mlib_u32 *) da;
      pws = (mlib_u32 *) (sa - lshift);
      lshift <<= 3;
      rshift = 32 - lshift;

      src1 = pws[0];
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
      for (i = 0; j <= (b_size - 4); j += 4, i++) {
        src0 = src1;
        src1 = pws[i + 1];
#ifdef _LITTLE_ENDIAN
        pwd[i] = (src0 >> lshift) | (src1 << rshift);
#else
        pwd[i] = (src0 << lshift) | (src1 >> rshift);
#endif /* _LITTLE_ENDIAN */
      }

      sa += i << 2;
      da += i << 2;
    }

#else
    mlib_u64 *pws, *pwd, src0, src1;
    mlib_s32 lshift = (mlib_s32) ((mlib_addr) sa & 7), rshift;

    pwd = (mlib_u64 *) da;
    pws = (mlib_u64 *) (sa - lshift);
    lshift <<= 3;
    rshift = 64 - lshift;

    src1 = pws[0];
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
    for (i = 0; j <= (b_size - 8); j += 8, i++) {
      src0 = src1;
      src1 = pws[i + 1];
      pwd[i] = (src0 << lshift) | (src1 >> rshift);
    }

    sa += i << 3;
    da += i << 3;
#endif /* _NO_LONGLONG */
  }

  for (; j < b_size; j++)
    *da++ = *sa++;

  j = size & 7;

  if (j > 0) {
    mask = mask0 << (8 - j);
    src = da[0];
    da[0] = (src & (~mask)) | (sa[0] & mask);
  }
}

/***************************************************************/
void mlib_c_ImageCopy_u8(const mlib_image *src,
                         mlib_image       *dst)
{
  PREPAREVARS(mlib_u8);
  if (src_width < 16) {
    STRIP(pdst, psrc, src_width, src_height, mlib_u8);
    return;
  }

  for (i = 0; i < src_height; i++) {
    mlib_u8 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride;

    if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 7)) {
      for (j = 0; j < (mlib_s32) ((8 - (mlib_addr) psrc_row) & 7); j++) {
        pdst_row[j] = psrc_row[j];
      }

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
      for (; j <= (src_width - 8); j += 8) {
        TYPE_64BIT dsrc0 = *((TYPE_64BIT *) (psrc_row + j));

        *((TYPE_64BIT *) (pdst_row + j)) = dsrc0;
      }
    }
    else {

#ifdef _NO_LONGLONG

      for (j = 0; j < (mlib_s32) ((4 - (mlib_addr) pdst_row) & 3); j++) {
        pdst_row[j] = psrc_row[j];
      }

      if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 3)) {
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
        for (; j <= (src_width - 4); j += 4) {
          *((mlib_s32 *) (pdst_row + j)) = *((mlib_s32 *) (psrc_row + j));
        }
      }
      else {
        mlib_u32 *ps, shl, shr, src0, src1;

        ps = (mlib_u32 *) (psrc_row + j);
        shl = (mlib_addr) ps & 3;
        ps = (mlib_u32 *) ((mlib_addr) ps - shl);
        shl <<= 3;
        shr = 32 - shl;

        src1 = ps[0];
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
        for (; j <= (src_width - 4); j += 4) {
          src0 = src1;
          src1 = ps[1];
#ifdef _LITTLE_ENDIAN
          *((mlib_s32 *) (pdst_row + j)) = (src0 >> shl) | (src1 << shr);
#else
          *((mlib_s32 *) (pdst_row + j)) = (src0 << shl) | (src1 >> shr);
#endif /* _LITTLE_ENDIAN */
          ps++;
        }
      }

#else

      for (j = 0; j < (mlib_s32) ((8 - (mlib_addr) pdst_row) & 7); j++) {
        pdst_row[j] = psrc_row[j];
      }

      {
        mlib_s32 shl, shr;
        mlib_u64 *ps, src0, src1;

        ps = (mlib_u64 *) (psrc_row + j);
        /* shl and shr are in range [0, 64] */
        shl = (mlib_s32) ((mlib_addr) ps & 7);
        ps = (mlib_u64 *) ((mlib_addr) ps - shl);
        shl <<= 3;
        shr = 64 - shl;

        src1 = ps[0];
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
        for (; j <= (src_width - 8); j += 8) {
          src0 = src1;
          src1 = ps[1];
#ifdef _LITTLE_ENDIAN
          *((mlib_s64 *) (pdst_row + j)) = (src0 >> shl) | (src1 << shr);
#else
          *((mlib_s64 *) (pdst_row + j)) = (src0 << shl) | (src1 >> shr);
#endif /* _LITTLE_ENDIAN */
          ps++;
        }
      }
#endif /* _NO_LONGLONG */
    }

    for (; j < src_width; j++)
      pdst_row[j] = psrc_row[j];
  }
}

/***************************************************************/
void mlib_c_ImageCopy_s16(const mlib_image       *src,
                          mlib_image *dst)
{
  PREPAREVARS(mlib_u16);
  if (src_width < 8) {
    STRIP(pdst, psrc, src_width, src_height, mlib_u16);
    return;
  }

  for (i = 0; i < src_height; i++) {
    mlib_u16 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride;

    if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 7)) {
      for (j = 0; j < (mlib_s32) (((8 - (mlib_addr) psrc_row) & 7) >> 1); j++) {
        pdst_row[j] = psrc_row[j];
      }

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
      for (; j <= (src_width - 4); j += 4) {
        TYPE_64BIT dsrc0 = *((TYPE_64BIT *) (psrc_row + j));

        *((TYPE_64BIT *) (pdst_row + j)) = dsrc0;
      }
    }
    else {

#ifdef _NO_LONGLONG

      if (j = (((mlib_addr) pdst_row & 2) != 0)) {
        pdst_row[0] = psrc_row[0];
      }

      if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 3)) {
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
        for (; j <= (src_width - 2); j += 2) {
          *((mlib_s32 *) (pdst_row + j)) = *((mlib_s32 *) (psrc_row + j));
        }
      }
      else {
        mlib_u32 *ps, src0, src1;

        ps = (mlib_u32 *) (psrc_row + j - 1);
        src1 = ps[0];
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
        for (; j <= (src_width - 2); j += 2) {
          src0 = src1;
          src1 = ps[1];
#ifdef _LITTLE_ENDIAN
          *((mlib_s32 *) (pdst_row + j)) = (src0 >> 16) | (src1 << 16);
#else
          *((mlib_s32 *) (pdst_row + j)) = (src0 << 16) | (src1 >> 16);
#endif /* _LITTLE_ENDIAN */
          ps++;
        }
      }

#else

      for (j = 0; j < (mlib_s32) (((8 - (mlib_addr) pdst_row) & 7) >> 1); j++) {
        pdst_row[j] = psrc_row[j];
      }

      {
        mlib_s32 shl, shr;
        mlib_u64 *ps, src0, src1;

        ps = (mlib_u64 *) (psrc_row + j);
        shl = (mlib_s32) ((mlib_addr) ps & 7);
        ps = (mlib_u64 *) ((mlib_addr) ps - shl);
        shl <<= 3;
        shr = 64 - shl;

        src1 = ps[0];
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
        for (; j <= (src_width - 4); j += 4) {
          src0 = src1;
          src1 = ps[1];
#ifdef _LITTLE_ENDIAN
          *((mlib_s64 *) (pdst_row + j)) = (src0 >> shl) | (src1 << shr);
#else
          *((mlib_s64 *) (pdst_row + j)) = (src0 << shl) | (src1 >> shr);
#endif /* _LITTLE_ENDIAN */
          ps++;
        }
      }
#endif /* _NO_LONGLONG */
    }

    for (; j < src_width; j++)
      pdst_row[j] = psrc_row[j];
  }
}

/***************************************************************/
void mlib_c_ImageCopy_s32(const mlib_image       *src,
                          mlib_image *dst)
{
  PREPAREVARS(mlib_u32);
  if (src_width < 4) {
    STRIP(pdst, psrc, src_width, src_height, mlib_u32);
    return;
  }

  for (i = 0; i < src_height; i++) {
    mlib_u32 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride;

    if (!(((mlib_addr) psrc_row ^ (mlib_addr) pdst_row) & 7)) {
      if ((j = ((mlib_s32) ((mlib_addr) psrc_row & 4) >> 2))) {
        pdst_row[0] = psrc_row[0];
      }

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
      for (; j <= (src_width - 2); j += 2) {
        TYPE_64BIT dsrc0 = *((TYPE_64BIT *) (psrc_row + j));

        *((TYPE_64BIT *) (pdst_row + j)) = dsrc0;
      }
    }
    else {

#ifdef _NO_LONGLONG

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
      for (j = 0; j <= (src_width - 1); j++) {
        *((mlib_s32 *) (pdst_row + j)) = *((mlib_s32 *) (psrc_row + j));
      }

#else

      {
        mlib_u64 *ps, src0, src1;

        if ((j = ((mlib_s32) ((mlib_addr) pdst_row & 4) >> 2)))
          pdst_row[0] = psrc_row[0];
        ps = (mlib_u64 *) (psrc_row + j - 1);
        src1 = ps[0];
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
        for (; j <= (src_width - 2); j += 2) {
          src0 = src1;
          src1 = ps[1];
#ifdef _LITTLE_ENDIAN
          *((mlib_s64 *) (pdst_row + j)) = (src0 >> 32) | (src1 << 32);
#else
          *((mlib_s64 *) (pdst_row + j)) = (src0 << 32) | (src1 >> 32);
#endif /* _LITTLE_ENDIAN */
          ps++;
        }
      }
#endif /* _NO_LONGLONG */
    }

    for (; j < src_width; j++)
      pdst_row[j] = psrc_row[j];
  }
}

/***************************************************************/
void mlib_c_ImageCopy_d64(const mlib_image       *src,
                          mlib_image *dst)
{
  PREPAREVARS(mlib_d64);
  for (i = 0; i < src_height; i++) {
    mlib_d64 *psrc_row = psrc + i * src_stride, *pdst_row = pdst + i * dst_stride;

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
    for (j = 0; j < src_width; j++)
      *((mlib_d64 *) (pdst_row + j)) = *((mlib_d64 *) (psrc_row + j));
  }
}

/***************************************************************/
/*
 * Both source and destination image data are 1 - d vectors and
 * 8 - byte aligned. And size is in 8 - bytes.
 */

void mlib_c_ImageCopy_a1(const TYPE_64BIT *sp,
                         TYPE_64BIT       *dp,
                         mlib_s32         size)
{
  mlib_s32 i;

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
  for (i = 0; i < size; i++) {
    *dp++ = *sp++;
  }
}

/***************************************************************/
#ifndef _NO_LONGLONG
#define TYPE    mlib_u64
#define BSIZE   64
#define SIZE    8
#else
#define TYPE    mlib_u32
#define BSIZE   32
#define SIZE    4
#endif /* _NO_LONGLONG */

/***************************************************************/
void mlib_ImageCopy_na(const mlib_u8 *sp,
                       mlib_u8       *dp,
                       mlib_s32      n)
{
  mlib_s32 shr, shl;
  TYPE *tmp, s0, s1;

  if (((mlib_addr) sp ^ (mlib_addr) dp) & 7) {

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
    for (; (n > 0) && (mlib_addr) dp & (SIZE - 1); n--)
      *dp++ = *sp++;

#ifdef _NO_LONGLONG

    if (((mlib_addr) sp & (SIZE - 1)) == 0) {
      for (; n > SIZE; n -= SIZE) {
        *(TYPE *) dp = *(TYPE *) sp;
        dp += SIZE;
        sp += SIZE;
      }
    }
    else
#endif /* _NO_LONGLONG */
    {
      tmp = (TYPE *) ((mlib_addr) sp & ~(SIZE - 1));
      /* shl and shr do not exceed 64 here */
      shl = (mlib_s32) (((mlib_addr) sp & (SIZE - 1)) << 3);
      shr = BSIZE - shl;
      s0 = *tmp++;

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
      for (; n > SIZE; n -= SIZE) {
        s1 = *tmp++;
#ifdef _LITTLE_ENDIAN
        *(TYPE *) dp = (s0 >> shl) | (s1 << shr);
#else
        *(TYPE *) dp = (s0 << shl) | (s1 >> shr);
#endif /* _LITTLE_ENDIAN */
        s0 = s1;
        dp += SIZE;
        sp += SIZE;
      }
    }
  }
  else {
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
    for (; (n > 0) && (mlib_addr) dp & 7; n--)
      *dp++ = *sp++;

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
    for (; n > 8; n -= 8) {
      *(TYPE_64BIT *) dp = *(TYPE_64BIT *) sp;
      dp += 8;
      sp += 8;
    }
  }

#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
  for (; n > 0; n--)
    *dp++ = *sp++;
}

/***************************************************************/
#ifdef _MSC_VER
#pragma optimize("", on)
#endif /* _MSC_VER */

/***************************************************************/