#ifndef __HAVE_ARCH_STRCPY

 /**

  * strcpy - Copy a %NUL terminated string

  * @dest: Where to copy the string to

  * @src: Where to copy the string from

  */

 char *strcpy(char *dest, const char *src)

 {

         char *tmp = dest;

         while ((*dest++ = *src++) != '\0')

                 /* nothing */;

         return tmp;

 }

 /**

  * memcpy - Copy one area of memory to another

  * @dest: Where to copy to

  * @src: Where to copy from

  * @count: The size of the area.

  *

  * You should not use this function to access IO space, use memcpy_toio()

  * or memcpy_fromio() instead.

  */

 void *memcpy(void *dest, const void *src, size_t count)

 {

         char *tmp = dest;

         const char *s = src;

         while (count--)

                 *tmp++ = *s++;

         return dest;

 }

 #ifndef __HAVE_ARCH_STRCMP

 /**

  * strcmp - Compare two strings

  * @cs: One string

  * @ct: Another string

  */

 int strcmp(const char *cs, const char *ct)

 {

         unsigned char c1, c2;

         while () {

                 c1 = *cs++;

                 c2 = *ct++;

                 if (c1 != c2)

                         return c1 < c2 ? - : ;

                 if (!c1)

                         break;

         }

         return ;

 }

 /**

  * strncmp - Compare two length-limited strings

  * @cs: One string

  * @ct: Another string

  * @count: The maximum number of bytes to compare

  */

 int strncmp(const char *cs, const char *ct, size_t count)

 {

         unsigned char c1, c2;

         while (count) {

                 c1 = *cs++;

                 c2 = *ct++;

                 if (c1 != c2)

                         return c1 < c2 ? - : ;

                 if (!c1)

                         break;

                 count--;

         }

         return ;

 }

 /**

  * strlen - Find the length of a string

  * @s: The string to be sized

  */

 size_t strlen(const char *s)

 {

         const char *sc;

         for (sc = s; *sc != '\0'; ++sc)

                 /* nothing */;

         return sc - s;

 }

 /**

  * memset - Fill a region of memory with the given value

  * @s: Pointer to the start of the area.

  * @c: The byte to fill the area with

  * @count: The size of the area.

  *

  * Do not use memset() to access IO space, use memset_io() instead.

  */

 void *memset(void *s, int c, size_t count)

 {

         char *xs = s;

         while (count--)

                 *xs++ = c;

         return s;

 }

 /**

  * memmove - Copy one area of memory to another

  * @dest: Where to copy to

  * @src: Where to copy from

  * @count: The size of the area.

  *

  * Unlike memcpy(), memmove() copes with overlapping areas.

  */

 void *memmove(void *dest, const void *src, size_t count)

 {

         char *tmp;

         const char *s;

         if (dest <= src) {

                 tmp = dest;

                 s = src;

                 while (count--)

                         *tmp++ = *s++;

         } else {

                 tmp = dest;

                 tmp += count;

                 s = src;

                 s += count;

                 while (count--)

                         *--tmp = *--s;

         }

         return dest;

 }

 /**

  * memcmp - Compare two areas of memory

  * @cs: One area of memory

  * @ct: Another area of memory

  * @count: The size of the area.

  */

 int memcmp(const void *cs, const void *ct, size_t count)

 {

         const unsigned char *su1, *su2;

         int res = ;

         for (su1 = cs, su2 = ct;  < count; ++su1, ++su2, count--)

                 if ((res = *su1 - *su2) != )

                         break;

         return res;

 }