path: root/recipes/xorg-driver/xf86-video-msm/no_neon.patch

commit d8910bf773fbecf7cdea359d4b530a3672e27180
Author: David Lanzendörfer <david.lanzendoerfer@o2s.ch>
Date:   Wed Feb 10 16:18:39 2010 +0100

    Removed neon because its not available in our kerneÃl
    and so its causing trubble (Illegal instruction)

diff --git git/src/msm-swblits.h git/src/msm-swblits.h
index f89f00e..a40b24b 100755
--- git/src/msm-swblits.h
+++ git/src/msm-swblits.h
@@ -38,16 +38,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-/* Neon intrinsics are part of the ARM or GCC compiler used.                                                              */
-/* Tested with: /pkg/asw/compilers/gnu/codesourcery/arm-2008q3-72/lib/gcc/arm-none-linux-gnueabi/4.3.2/include/arm_neon.h */
-#include <arm_neon.h>
-
-/* These are NEON-optimized functions linked to by various tests.  */
-extern void * neon_memcpy (void * dest, const void * source, unsigned int numBytes);
-extern void * neon_memmove (void * dest, const void * source, unsigned int numBytes);
-extern void memset16(uint16_t *dst, uint16_t value, int count);
-extern void memset32(uint32_t *dst, uint32_t value, int count);
-
 /* Make definitions to clarify memory-related sizes to enable avoidance of magic numbers. */
 #define BITS_PER_BYTE (8)
 #define BYTES_PER_16BPP_PIXEL (2)
diff --git git/src/msm-swfill.c git/src/msm-swfill.c
index 108fd94..3dd1ef2 100755
--- git/src/msm-swfill.c
+++ git/src/msm-swfill.c
@@ -212,7 +212,7 @@ memset16_NeonAlignmentAssumptions_UpTo7Count(uint8_t *dst, uint16_t src, int cou
    }
 }
 
-
+/*
 static inline void
 memset16_AssumesNeonAlignment(uint8_t *dst, uint16_t src, int count)
 {
@@ -333,7 +333,7 @@ memset16_AssumesNeonAlignment(uint8_t *dst, uint16_t src, int count)
    // Quickly fill remaining pixels (up to 7).
    memset16_NeonAlignmentAssumptions_UpTo7Count(dst, src, count);
 }
-
+*/
 
 static inline void
 memset16_Test(uint16_t *dst, uint16_t src, int count)
@@ -368,7 +368,8 @@ memset16_Test(uint16_t *dst, uint16_t src, int count)
 
       // Copy remaining pixels using Neon and non-Neon instructions.
       // NOTE: This assumes that dst is aligned optimally for Neon instructions.
-      memset16_AssumesNeonAlignment((void *) dst, src, count);
+      //memset16_AssumesNeonAlignment((void *) dst, src, count);
+      memset((void *) dst, src, count);
    }
 }
 
@@ -435,12 +436,14 @@ swFillRect32Bpp_Unaligned(unsigned char *dst, uint32_t src, int w, int h, int dp
    if (w < 32) {
       // For narrow rectangles, block signals only once for the entire rectangles.
       BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS();
-      DO_MULTIPLE_FILLS_WITH_MEMSET(memset32,SIGNAL_BLOCK_NOOP,SIGNAL_BLOCK_NOOP);
+      //DO_MULTIPLE_FILLS_WITH_MEMSET(memset32,SIGNAL_BLOCK_NOOP,SIGNAL_BLOCK_NOOP);
+      DO_MULTIPLE_FILLS_WITH_MEMSET(memset,SIGNAL_BLOCK_NOOP,SIGNAL_BLOCK_NOOP);
       UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS();
    }
    else {
       // For wider rectangles, block and unblock signals for every row.
-      DO_MULTIPLE_FILLS_WITH_MEMSET(memset32,BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS,UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+      //DO_MULTIPLE_FILLS_WITH_MEMSET(memset32,BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS,UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+      DO_MULTIPLE_FILLS_WITH_MEMSET(memset,BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS,UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
    }
 }
 
diff --git git/src/msm-swrender.c git/src/msm-swrender.c
index a7a9abc..835dc03 100755
--- git/src/msm-swrender.c
+++ git/src/msm-swrender.c
@@ -214,160 +214,6 @@ swCopy16BppSmallFixedWidths1Row_Unaligned(unsigned char *dst, unsigned char *src
                   }
                }
                break;
-      case  7: if (xdir >= 0) {
-                  swCopy16BppSmallFixedWidths1Row_Unaligned(dst, src, 4, xdir);
-                  swCopy16BppSmallFixedWidths1Row_Unaligned(dst + 4 * BYTES_PER_UINT16_T, src + 4 * BYTES_PER_UINT16_T, 3, xdir);
-                  return TRUE;
-               } else {
-                  swCopy16BppSmallFixedWidths1Row_Unaligned(dst + 4 * BYTES_PER_UINT16_T, src + 4 * BYTES_PER_UINT16_T, 3, xdir);
-                  swCopy16BppSmallFixedWidths1Row_Unaligned(dst, src, 4, xdir);
-                  return TRUE;
-               }
-               break;
-      case  8: if (SW_CHECK_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint32x4_t src1 = vld1q_u32((uint32_t *)(src+0*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*BYTES_PER_UINT32X4_T),src1);
-                  return TRUE;
-               }
-               else if (SW_CHECK_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint64_t src1  = *(uint64_t *) (src+0*BYTES_PER_UINT64_T);
-                  uint64_t src2  = *(uint64_t *) (src+1*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*BYTES_PER_UINT64_T)  = src1;
-                  *(uint64_t *) (dst+1*BYTES_PER_UINT64_T)  = src2;
-                  return TRUE;
-               }
-               else if (SW_CHECK_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint32_t src1  = *(uint32_t *) (src+0*BYTES_PER_UINT32_T);
-                  uint32_t src2  = *(uint32_t *) (src+1*BYTES_PER_UINT32_T);
-                  uint32_t src3  = *(uint32_t *) (src+2*BYTES_PER_UINT32_T);
-                  uint32_t src4  = *(uint32_t *) (src+3*BYTES_PER_UINT32_T);
-                  *(uint32_t *) (dst+0*BYTES_PER_UINT32_T)  = src1;
-                  *(uint32_t *) (dst+1*BYTES_PER_UINT32_T)  = src2;
-                  *(uint32_t *) (dst+2*BYTES_PER_UINT32_T)  = src3;
-                  *(uint32_t *) (dst+3*BYTES_PER_UINT32_T)  = src4;
-                  return TRUE;
-               }
-               else {
-                  uint16_t src1  = *(uint16_t *) (src+0*BYTES_PER_UINT16_T);
-                  uint16_t src2  = *(uint16_t *) (src+1*BYTES_PER_UINT16_T);
-                  uint16_t src3  = *(uint16_t *) (src+2*BYTES_PER_UINT16_T);
-                  uint16_t src4  = *(uint16_t *) (src+3*BYTES_PER_UINT16_T);
-                  uint16_t src5  = *(uint16_t *) (src+4*BYTES_PER_UINT16_T);
-                  uint16_t src6  = *(uint16_t *) (src+5*BYTES_PER_UINT16_T);
-                  uint16_t src7  = *(uint16_t *) (src+6*BYTES_PER_UINT16_T);
-                  uint16_t src8  = *(uint16_t *) (src+7*BYTES_PER_UINT16_T);
-                  *(uint16_t *) (dst+0*BYTES_PER_UINT16_T)  = src1;
-                  *(uint16_t *) (dst+1*BYTES_PER_UINT16_T)  = src2;
-                  *(uint16_t *) (dst+2*BYTES_PER_UINT16_T)  = src3;
-                  *(uint16_t *) (dst+3*BYTES_PER_UINT16_T)  = src4;
-                  *(uint16_t *) (dst+4*BYTES_PER_UINT16_T)  = src5;
-                  *(uint16_t *) (dst+5*BYTES_PER_UINT16_T)  = src6;
-                  *(uint16_t *) (dst+6*BYTES_PER_UINT16_T)  = src7;
-                  *(uint16_t *) (dst+7*BYTES_PER_UINT16_T)  = src8;
-                  return TRUE;
-               }
-               break;
-      case 16: if (SW_CHECK_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint32x4_t src1 = vld1q_u32((uint32_t *)(src+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2 = vld1q_u32((uint32_t *)(src+1*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*BYTES_PER_UINT32X4_T),src1);
-                  vst1q_u32((uint32_t *)(dst+1*BYTES_PER_UINT32X4_T),src2);
-                  return TRUE;
-               }
-               else if (SW_CHECK_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint64_t src1  = *(uint64_t *) (src+0*BYTES_PER_UINT64_T);
-                  uint64_t src2  = *(uint64_t *) (src+1*BYTES_PER_UINT64_T);
-                  uint64_t src3  = *(uint64_t *) (src+2*BYTES_PER_UINT64_T);
-                  uint64_t src4  = *(uint64_t *) (src+3*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*BYTES_PER_UINT64_T)  = src1;
-                  *(uint64_t *) (dst+1*BYTES_PER_UINT64_T)  = src2;
-                  *(uint64_t *) (dst+2*BYTES_PER_UINT64_T)  = src3;
-                  *(uint64_t *) (dst+3*BYTES_PER_UINT64_T)  = src4;
-                  return TRUE;
-               }
-               else if (SW_CHECK_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint32_t src1  = *(uint32_t *) (src+0*BYTES_PER_UINT32_T);
-                  uint32_t src2  = *(uint32_t *) (src+1*BYTES_PER_UINT32_T);
-                  uint32_t src3  = *(uint32_t *) (src+2*BYTES_PER_UINT32_T);
-                  uint32_t src4  = *(uint32_t *) (src+3*BYTES_PER_UINT32_T);
-                  uint32_t src5  = *(uint32_t *) (src+4*BYTES_PER_UINT32_T);
-                  uint32_t src6  = *(uint32_t *) (src+5*BYTES_PER_UINT32_T);
-                  uint32_t src7  = *(uint32_t *) (src+6*BYTES_PER_UINT32_T);
-                  uint32_t src8  = *(uint32_t *) (src+7*BYTES_PER_UINT32_T);
-                  *(uint32_t *) (dst+0*BYTES_PER_UINT32_T)  = src1;
-                  *(uint32_t *) (dst+1*BYTES_PER_UINT32_T)  = src2;
-                  *(uint32_t *) (dst+2*BYTES_PER_UINT32_T)  = src3;
-                  *(uint32_t *) (dst+3*BYTES_PER_UINT32_T)  = src4;
-                  *(uint32_t *) (dst+4*BYTES_PER_UINT32_T)  = src5;
-                  *(uint32_t *) (dst+5*BYTES_PER_UINT32_T)  = src6;
-                  *(uint32_t *) (dst+6*BYTES_PER_UINT32_T)  = src7;
-                  *(uint32_t *) (dst+7*BYTES_PER_UINT32_T)  = src8;
-                  return TRUE;
-               }
-               else {
-                  // Don't bother unrolling loops here, since that won't help for more than around 8 operations.
-                  // Instead, just call multiple fixed functions.
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths1Row_Unaligned(dst, src, 8, xdir);
-                     swCopy16BppSmallFixedWidths1Row_Unaligned(dst + 8 * BYTES_PER_UINT16_T, src + 8 * BYTES_PER_UINT16_T, 8, xdir);
-                  } else {
-                     swCopy16BppSmallFixedWidths1Row_Unaligned(dst + 8 * BYTES_PER_UINT16_T, src + 8 * BYTES_PER_UINT16_T, 8, xdir);
-                     swCopy16BppSmallFixedWidths1Row_Unaligned(dst, src, 8, xdir);
-                  }
-                  return TRUE;
-               }
-               break;
-      case 32: if (SW_CHECK_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint32x4_t src1 = vld1q_u32((uint32_t *)(src+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2 = vld1q_u32((uint32_t *)(src+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3 = vld1q_u32((uint32_t *)(src+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4 = vld1q_u32((uint32_t *)(src+3*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*BYTES_PER_UINT32X4_T),src1);
-                  vst1q_u32((uint32_t *)(dst+1*BYTES_PER_UINT32X4_T),src2);
-                  vst1q_u32((uint32_t *)(dst+2*BYTES_PER_UINT32X4_T),src3);
-                  vst1q_u32((uint32_t *)(dst+3*BYTES_PER_UINT32X4_T),src4);
-                  return TRUE;
-               }
-               else if (SW_CHECK_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint64_t src1  = *(uint64_t *) (src+0*BYTES_PER_UINT64_T);
-                  uint64_t src2  = *(uint64_t *) (src+1*BYTES_PER_UINT64_T);
-                  uint64_t src3  = *(uint64_t *) (src+2*BYTES_PER_UINT64_T);
-                  uint64_t src4  = *(uint64_t *) (src+3*BYTES_PER_UINT64_T);
-                  uint64_t src5  = *(uint64_t *) (src+4*BYTES_PER_UINT64_T);
-                  uint64_t src6  = *(uint64_t *) (src+5*BYTES_PER_UINT64_T);
-                  uint64_t src7  = *(uint64_t *) (src+6*BYTES_PER_UINT64_T);
-                  uint64_t src8  = *(uint64_t *) (src+7*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*BYTES_PER_UINT64_T)  = src1;
-                  *(uint64_t *) (dst+1*BYTES_PER_UINT64_T)  = src2;
-                  *(uint64_t *) (dst+2*BYTES_PER_UINT64_T)  = src3;
-                  *(uint64_t *) (dst+3*BYTES_PER_UINT64_T)  = src4;
-                  *(uint64_t *) (dst+4*BYTES_PER_UINT64_T)  = src5;
-                  *(uint64_t *) (dst+5*BYTES_PER_UINT64_T)  = src6;
-                  *(uint64_t *) (dst+6*BYTES_PER_UINT64_T)  = src7;
-                  *(uint64_t *) (dst+7*BYTES_PER_UINT64_T)  = src8;
-                  return TRUE;
-               }
-               break;
-      case 64: if (SW_CHECK_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,0)) {
-                  uint32x4_t src1 = vld1q_u32((uint32_t *)(src+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2 = vld1q_u32((uint32_t *)(src+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3 = vld1q_u32((uint32_t *)(src+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4 = vld1q_u32((uint32_t *)(src+3*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src5 = vld1q_u32((uint32_t *)(src+4*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src6 = vld1q_u32((uint32_t *)(src+5*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src7 = vld1q_u32((uint32_t *)(src+6*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src8 = vld1q_u32((uint32_t *)(src+7*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*BYTES_PER_UINT32X4_T),src1);
-                  vst1q_u32((uint32_t *)(dst+1*BYTES_PER_UINT32X4_T),src2);
-                  vst1q_u32((uint32_t *)(dst+2*BYTES_PER_UINT32X4_T),src3);
-                  vst1q_u32((uint32_t *)(dst+3*BYTES_PER_UINT32X4_T),src4);
-                  vst1q_u32((uint32_t *)(dst+4*BYTES_PER_UINT32X4_T),src5);
-                  vst1q_u32((uint32_t *)(dst+5*BYTES_PER_UINT32X4_T),src6);
-                  vst1q_u32((uint32_t *)(dst+6*BYTES_PER_UINT32X4_T),src7);
-                  vst1q_u32((uint32_t *)(dst+7*BYTES_PER_UINT32X4_T),src8);
-                  return TRUE;
-               }
-               break;
    }
 
    return FALSE;
@@ -519,427 +365,6 @@ swCopy16BppSmallFixedWidths2Rows_Unaligned(unsigned char *dst, unsigned char *sr
                }
                return TRUE;
                break;
-      case  7: if (xdir >= 0) {
-                  swCopy16BppSmallFixedWidths2Rows_Unaligned(dst, src, 4, xdir, dpitch, spitch);
-                  swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 4 * BYTES_PER_UINT16_T, src + 4 * BYTES_PER_UINT16_T, 3, xdir, dpitch, spitch);
-               } else {
-                  swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 4 * BYTES_PER_UINT16_T, src + 4 * BYTES_PER_UINT16_T, 3, xdir, dpitch, spitch);
-                  swCopy16BppSmallFixedWidths2Rows_Unaligned(dst, src, 4, xdir, dpitch, spitch);
-               }
-               return TRUE;
-               break;
-      case  8: if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32x4_t src1a = vld1q_u32((uint32_t *)(src+0*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1b = vld1q_u32((uint32_t *)(src+1*spitch+0*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+0*BYTES_PER_UINT32X4_T),src1a);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+0*BYTES_PER_UINT32X4_T),src1b);
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint64_t src1a = *(uint64_t *) (src+0*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2a = *(uint64_t *) (src+0*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src1b = *(uint64_t *) (src+1*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2b = *(uint64_t *) (src+1*spitch+1*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*dpitch+0*BYTES_PER_UINT64_T)  = src1a;
-                  *(uint64_t *) (dst+0*dpitch+1*BYTES_PER_UINT64_T)  = src2a;
-                  *(uint64_t *) (dst+1*dpitch+0*BYTES_PER_UINT64_T)  = src1b;
-                  *(uint64_t *) (dst+1*dpitch+1*BYTES_PER_UINT64_T)  = src2b;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32_t src1a = *(uint32_t *) (src+0*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2a = *(uint32_t *) (src+0*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3a = *(uint32_t *) (src+0*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4a = *(uint32_t *) (src+0*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src1b = *(uint32_t *) (src+1*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2b = *(uint32_t *) (src+1*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3b = *(uint32_t *) (src+1*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4b = *(uint32_t *) (src+1*spitch+3*BYTES_PER_UINT32_T);
-                  *(uint32_t *) (dst+0*dpitch+0*BYTES_PER_UINT32_T)  = src1a;
-                  *(uint32_t *) (dst+0*dpitch+1*BYTES_PER_UINT32_T)  = src2a;
-                  *(uint32_t *) (dst+0*dpitch+2*BYTES_PER_UINT32_T)  = src3a;
-                  *(uint32_t *) (dst+0*dpitch+3*BYTES_PER_UINT32_T)  = src4a;
-                  *(uint32_t *) (dst+1*dpitch+0*BYTES_PER_UINT32_T)  = src1b;
-                  *(uint32_t *) (dst+1*dpitch+1*BYTES_PER_UINT32_T)  = src2b;
-                  *(uint32_t *) (dst+1*dpitch+2*BYTES_PER_UINT32_T)  = src3b;
-                  *(uint32_t *) (dst+1*dpitch+3*BYTES_PER_UINT32_T)  = src4b;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,BYTES_PER_UINT16_T)) {
-                  uint16_t src1a = *(uint16_t *) (src+0*spitch+0);
-                  uint32_t src2a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint16_t src5a = *(uint16_t *) (src+0*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint16_t src1b = *(uint16_t *) (src+1*spitch+0);
-                  uint32_t src2b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint16_t src5b = *(uint16_t *) (src+1*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  *(uint16_t *) (dst+0*dpitch+0)                                        = src1a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4a;
-                  *(uint16_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5a;
-                  *(uint16_t *) (dst+1*dpitch+0)                                        = src1b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4b;
-                  *(uint16_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5b;
-                  return TRUE;
-               }
-               else {
-                  uint16_t src1a = *(uint16_t *) (src+0*spitch+0*BYTES_PER_UINT16_T);
-                  uint16_t src2a = *(uint16_t *) (src+0*spitch+1*BYTES_PER_UINT16_T);
-                  uint16_t src3a = *(uint16_t *) (src+0*spitch+2*BYTES_PER_UINT16_T);
-                  uint16_t src4a = *(uint16_t *) (src+0*spitch+3*BYTES_PER_UINT16_T);
-                  uint16_t src5a = *(uint16_t *) (src+0*spitch+4*BYTES_PER_UINT16_T);
-                  uint16_t src6a = *(uint16_t *) (src+0*spitch+5*BYTES_PER_UINT16_T);
-                  uint16_t src7a = *(uint16_t *) (src+0*spitch+6*BYTES_PER_UINT16_T);
-                  uint16_t src8a = *(uint16_t *) (src+0*spitch+7*BYTES_PER_UINT16_T);
-                  uint16_t src1b = *(uint16_t *) (src+1*spitch+0*BYTES_PER_UINT16_T);
-                  uint16_t src2b = *(uint16_t *) (src+1*spitch+1*BYTES_PER_UINT16_T);
-                  uint16_t src3b = *(uint16_t *) (src+1*spitch+2*BYTES_PER_UINT16_T);
-                  uint16_t src4b = *(uint16_t *) (src+1*spitch+3*BYTES_PER_UINT16_T);
-                  uint16_t src5b = *(uint16_t *) (src+1*spitch+4*BYTES_PER_UINT16_T);
-                  uint16_t src6b = *(uint16_t *) (src+1*spitch+5*BYTES_PER_UINT16_T);
-                  uint16_t src7b = *(uint16_t *) (src+1*spitch+6*BYTES_PER_UINT16_T);
-                  uint16_t src8b = *(uint16_t *) (src+1*spitch+7*BYTES_PER_UINT16_T);
-                  *(uint16_t *) (dst+0*dpitch+0*BYTES_PER_UINT16_T)  = src1a;
-                  *(uint16_t *) (dst+0*dpitch+1*BYTES_PER_UINT16_T)  = src2a;
-                  *(uint16_t *) (dst+0*dpitch+2*BYTES_PER_UINT16_T)  = src3a;
-                  *(uint16_t *) (dst+0*dpitch+3*BYTES_PER_UINT16_T)  = src4a;
-                  *(uint16_t *) (dst+0*dpitch+4*BYTES_PER_UINT16_T)  = src5a;
-                  *(uint16_t *) (dst+0*dpitch+5*BYTES_PER_UINT16_T)  = src6a;
-                  *(uint16_t *) (dst+0*dpitch+6*BYTES_PER_UINT16_T)  = src7a;
-                  *(uint16_t *) (dst+0*dpitch+7*BYTES_PER_UINT16_T)  = src8a;
-                  *(uint16_t *) (dst+1*dpitch+0*BYTES_PER_UINT16_T)  = src1b;
-                  *(uint16_t *) (dst+1*dpitch+1*BYTES_PER_UINT16_T)  = src2b;
-                  *(uint16_t *) (dst+1*dpitch+2*BYTES_PER_UINT16_T)  = src3b;
-                  *(uint16_t *) (dst+1*dpitch+3*BYTES_PER_UINT16_T)  = src4b;
-                  *(uint16_t *) (dst+1*dpitch+4*BYTES_PER_UINT16_T)  = src5b;
-                  *(uint16_t *) (dst+1*dpitch+5*BYTES_PER_UINT16_T)  = src6b;
-                  *(uint16_t *) (dst+1*dpitch+6*BYTES_PER_UINT16_T)  = src7b;
-                  *(uint16_t *) (dst+1*dpitch+7*BYTES_PER_UINT16_T)  = src8b;
-                  return TRUE;
-               }
-               break;
-      case 16: if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32x4_t src1a = vld1q_u32((uint32_t *)(src+0*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2a = vld1q_u32((uint32_t *)(src+0*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1b = vld1q_u32((uint32_t *)(src+1*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2b = vld1q_u32((uint32_t *)(src+1*spitch+1*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+0*BYTES_PER_UINT32X4_T),src1a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+1*BYTES_PER_UINT32X4_T),src2a);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+0*BYTES_PER_UINT32X4_T),src1b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+1*BYTES_PER_UINT32X4_T),src2b);
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint64_t src1a = *(uint64_t *) (src+0*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2a = *(uint64_t *) (src+0*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3a = *(uint64_t *) (src+0*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4a = *(uint64_t *) (src+0*spitch+3*BYTES_PER_UINT64_T);
-                  uint64_t src1b = *(uint64_t *) (src+1*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2b = *(uint64_t *) (src+1*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3b = *(uint64_t *) (src+1*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4b = *(uint64_t *) (src+1*spitch+3*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*dpitch+0*BYTES_PER_UINT64_T)  = src1a;
-                  *(uint64_t *) (dst+0*dpitch+1*BYTES_PER_UINT64_T)  = src2a;
-                  *(uint64_t *) (dst+0*dpitch+2*BYTES_PER_UINT64_T)  = src3a;
-                  *(uint64_t *) (dst+0*dpitch+3*BYTES_PER_UINT64_T)  = src4a;
-                  *(uint64_t *) (dst+1*dpitch+0*BYTES_PER_UINT64_T)  = src1b;
-                  *(uint64_t *) (dst+1*dpitch+1*BYTES_PER_UINT64_T)  = src2b;
-                  *(uint64_t *) (dst+1*dpitch+2*BYTES_PER_UINT64_T)  = src3b;
-                  *(uint64_t *) (dst+1*dpitch+3*BYTES_PER_UINT64_T)  = src4b;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,BYTES_PER_UINT32_T)) {
-                  uint32_t src1a = *(uint32_t *) (src+0*spitch+0);
-                  uint64_t src2a = *(uint64_t *) (src+0*spitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T);
-                  uint64_t src3a = *(uint64_t *) (src+0*spitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T);
-                  uint64_t src4a = *(uint64_t *) (src+0*spitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T);
-                  uint32_t src5a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T);
-                  uint32_t src1b = *(uint32_t *) (src+1*spitch+0);
-                  uint64_t src2b = *(uint64_t *) (src+1*spitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T);
-                  uint64_t src3b = *(uint64_t *) (src+1*spitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T);
-                  uint64_t src4b = *(uint64_t *) (src+1*spitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T);
-                  uint32_t src5b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T);
-                  *(uint32_t *) (dst+0*dpitch+0)                                        = src1a;
-                  *(uint64_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T)  = src2a;
-                  *(uint64_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T)  = src3a;
-                  *(uint64_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T)  = src4a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T)  = src5a;
-                  *(uint32_t *) (dst+1*dpitch+0)                                        = src1b;
-                  *(uint64_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T)  = src2b;
-                  *(uint64_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T)  = src3b;
-                  *(uint64_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T)  = src4b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T)  = src5b;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32_t src1a = *(uint32_t *) (src+0*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2a = *(uint32_t *) (src+0*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3a = *(uint32_t *) (src+0*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4a = *(uint32_t *) (src+0*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src5a = *(uint32_t *) (src+0*spitch+4*BYTES_PER_UINT32_T);
-                  uint32_t src6a = *(uint32_t *) (src+0*spitch+5*BYTES_PER_UINT32_T);
-                  uint32_t src7a = *(uint32_t *) (src+0*spitch+6*BYTES_PER_UINT32_T);
-                  uint32_t src8a = *(uint32_t *) (src+0*spitch+7*BYTES_PER_UINT32_T);
-                  uint32_t src1b = *(uint32_t *) (src+1*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2b = *(uint32_t *) (src+1*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3b = *(uint32_t *) (src+1*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4b = *(uint32_t *) (src+1*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src5b = *(uint32_t *) (src+1*spitch+4*BYTES_PER_UINT32_T);
-                  uint32_t src6b = *(uint32_t *) (src+1*spitch+5*BYTES_PER_UINT32_T);
-                  uint32_t src7b = *(uint32_t *) (src+1*spitch+6*BYTES_PER_UINT32_T);
-                  uint32_t src8b = *(uint32_t *) (src+1*spitch+7*BYTES_PER_UINT32_T);
-                  *(uint32_t *) (dst+0*dpitch+0*BYTES_PER_UINT32_T)  = src1a;
-                  *(uint32_t *) (dst+0*dpitch+1*BYTES_PER_UINT32_T)  = src2a;
-                  *(uint32_t *) (dst+0*dpitch+2*BYTES_PER_UINT32_T)  = src3a;
-                  *(uint32_t *) (dst+0*dpitch+3*BYTES_PER_UINT32_T)  = src4a;
-                  *(uint32_t *) (dst+0*dpitch+4*BYTES_PER_UINT32_T)  = src5a;
-                  *(uint32_t *) (dst+0*dpitch+5*BYTES_PER_UINT32_T)  = src6a;
-                  *(uint32_t *) (dst+0*dpitch+6*BYTES_PER_UINT32_T)  = src7a;
-                  *(uint32_t *) (dst+0*dpitch+7*BYTES_PER_UINT32_T)  = src8a;
-                  *(uint32_t *) (dst+1*dpitch+0*BYTES_PER_UINT32_T)  = src1b;
-                  *(uint32_t *) (dst+1*dpitch+1*BYTES_PER_UINT32_T)  = src2b;
-                  *(uint32_t *) (dst+1*dpitch+2*BYTES_PER_UINT32_T)  = src3b;
-                  *(uint32_t *) (dst+1*dpitch+3*BYTES_PER_UINT32_T)  = src4b;
-                  *(uint32_t *) (dst+1*dpitch+4*BYTES_PER_UINT32_T)  = src5b;
-                  *(uint32_t *) (dst+1*dpitch+5*BYTES_PER_UINT32_T)  = src6b;
-                  *(uint32_t *) (dst+1*dpitch+6*BYTES_PER_UINT32_T)  = src7b;
-                  *(uint32_t *) (dst+1*dpitch+7*BYTES_PER_UINT32_T)  = src8b;
-                  return TRUE;
-               }
-               else {
-                  // Don't bother unrolling loops, since that won't help for more than around 8 operations.
-                  // Instead, just call multiple fixed functions.
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst, src, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 8 * BYTES_PER_UINT16_T, src + 8 * BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 8 * BYTES_PER_UINT16_T, src + 8 * BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst, src, 8, xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               break;
-      case 32: if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32x4_t src1a = vld1q_u32((uint32_t *)(src+0*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2a = vld1q_u32((uint32_t *)(src+0*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3a = vld1q_u32((uint32_t *)(src+0*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4a = vld1q_u32((uint32_t *)(src+0*spitch+3*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1b = vld1q_u32((uint32_t *)(src+1*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2b = vld1q_u32((uint32_t *)(src+1*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3b = vld1q_u32((uint32_t *)(src+1*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4b = vld1q_u32((uint32_t *)(src+1*spitch+3*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+0*BYTES_PER_UINT32X4_T),src1a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+1*BYTES_PER_UINT32X4_T),src2a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+2*BYTES_PER_UINT32X4_T),src3a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+3*BYTES_PER_UINT32X4_T),src4a);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+0*BYTES_PER_UINT32X4_T),src1b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+1*BYTES_PER_UINT32X4_T),src2b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+2*BYTES_PER_UINT32X4_T),src3b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+3*BYTES_PER_UINT32X4_T),src4b);
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,4*BYTES_PER_UINT16_T)) {
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                           src + 0,                            4, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (4)*BYTES_PER_UINT16_T,      src + (4)*BYTES_PER_UINT16_T,      16, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (16+4)*BYTES_PER_UINT16_T,   src + (16+4)*BYTES_PER_UINT16_T,    8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (8+16+4)*BYTES_PER_UINT16_T, src + (8+16+4)*BYTES_PER_UINT16_T,  4, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (8+16+4)*BYTES_PER_UINT16_T, src + (8+16+4)*BYTES_PER_UINT16_T,  4, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (16+4)*BYTES_PER_UINT16_T,   src + (16+4)*BYTES_PER_UINT16_T,    8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (4)*BYTES_PER_UINT16_T,      src + (4)*BYTES_PER_UINT16_T,      16, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                           src + 0,                            4, xdir, dpitch, spitch);
-                   }
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint64_t src1a = *(uint64_t *) (src+0*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2a = *(uint64_t *) (src+0*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3a = *(uint64_t *) (src+0*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4a = *(uint64_t *) (src+0*spitch+3*BYTES_PER_UINT64_T);
-                  uint64_t src5a = *(uint64_t *) (src+0*spitch+4*BYTES_PER_UINT64_T);
-                  uint64_t src6a = *(uint64_t *) (src+0*spitch+5*BYTES_PER_UINT64_T);
-                  uint64_t src7a = *(uint64_t *) (src+0*spitch+6*BYTES_PER_UINT64_T);
-                  uint64_t src8a = *(uint64_t *) (src+0*spitch+7*BYTES_PER_UINT64_T);
-                  uint64_t src1b = *(uint64_t *) (src+1*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2b = *(uint64_t *) (src+1*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3b = *(uint64_t *) (src+1*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4b = *(uint64_t *) (src+1*spitch+3*BYTES_PER_UINT64_T);
-                  uint64_t src5b = *(uint64_t *) (src+1*spitch+4*BYTES_PER_UINT64_T);
-                  uint64_t src6b = *(uint64_t *) (src+1*spitch+5*BYTES_PER_UINT64_T);
-                  uint64_t src7b = *(uint64_t *) (src+1*spitch+6*BYTES_PER_UINT64_T);
-                  uint64_t src8b = *(uint64_t *) (src+1*spitch+7*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*dpitch+0*BYTES_PER_UINT64_T)  = src1a;
-                  *(uint64_t *) (dst+0*dpitch+1*BYTES_PER_UINT64_T)  = src2a;
-                  *(uint64_t *) (dst+0*dpitch+2*BYTES_PER_UINT64_T)  = src3a;
-                  *(uint64_t *) (dst+0*dpitch+3*BYTES_PER_UINT64_T)  = src4a;
-                  *(uint64_t *) (dst+0*dpitch+4*BYTES_PER_UINT64_T)  = src5a;
-                  *(uint64_t *) (dst+0*dpitch+5*BYTES_PER_UINT64_T)  = src6a;
-                  *(uint64_t *) (dst+0*dpitch+6*BYTES_PER_UINT64_T)  = src7a;
-                  *(uint64_t *) (dst+0*dpitch+7*BYTES_PER_UINT64_T)  = src8a;
-                  *(uint64_t *) (dst+1*dpitch+0*BYTES_PER_UINT64_T)  = src1b;
-                  *(uint64_t *) (dst+1*dpitch+1*BYTES_PER_UINT64_T)  = src2b;
-                  *(uint64_t *) (dst+1*dpitch+2*BYTES_PER_UINT64_T)  = src3b;
-                  *(uint64_t *) (dst+1*dpitch+3*BYTES_PER_UINT64_T)  = src4b;
-                  *(uint64_t *) (dst+1*dpitch+4*BYTES_PER_UINT64_T)  = src5b;
-                  *(uint64_t *) (dst+1*dpitch+5*BYTES_PER_UINT64_T)  = src6b;
-                  *(uint64_t *) (dst+1*dpitch+6*BYTES_PER_UINT64_T)  = src7b;
-                  *(uint64_t *) (dst+1*dpitch+7*BYTES_PER_UINT64_T)  = src8b;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,2*BYTES_PER_UINT16_T)) {
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 2, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+2)*BYTES_PER_UINT16_T, src + (0*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+2)*BYTES_PER_UINT16_T, src + (1*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+2)*BYTES_PER_UINT16_T, src + (2*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+2)*BYTES_PER_UINT16_T, src + (3*8+2)*BYTES_PER_UINT16_T, 6, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+2)*BYTES_PER_UINT16_T, src + (3*8+2)*BYTES_PER_UINT16_T, 6, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+2)*BYTES_PER_UINT16_T, src + (2*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+2)*BYTES_PER_UINT16_T, src + (1*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+2)*BYTES_PER_UINT16_T, src + (0*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 2, xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,BYTES_PER_UINT16_T)) {
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 1, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+1)*BYTES_PER_UINT16_T, src + (0*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+1)*BYTES_PER_UINT16_T, src + (1*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+1)*BYTES_PER_UINT16_T, src + (2*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+1)*BYTES_PER_UINT16_T, src + (3*8+1)*BYTES_PER_UINT16_T, 7, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+1)*BYTES_PER_UINT16_T, src + (3*8+1)*BYTES_PER_UINT16_T, 7, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+1)*BYTES_PER_UINT16_T, src + (2*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+1)*BYTES_PER_UINT16_T, src + (1*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+1)*BYTES_PER_UINT16_T, src + (0*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 1, xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               else {
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0*8*BYTES_PER_UINT16_T, src + 0*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 1*8*BYTES_PER_UINT16_T, src + 1*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 2*8*BYTES_PER_UINT16_T, src + 2*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 3*8*BYTES_PER_UINT16_T, src + 3*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 3*8*BYTES_PER_UINT16_T, src + 3*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 2*8*BYTES_PER_UINT16_T, src + 2*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 1*8*BYTES_PER_UINT16_T, src + 1*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0*8*BYTES_PER_UINT16_T, src + 0*8*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               break;
-      case 64: if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32x4_t src1a = vld1q_u32((uint32_t *)(src+0*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2a = vld1q_u32((uint32_t *)(src+0*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3a = vld1q_u32((uint32_t *)(src+0*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4a = vld1q_u32((uint32_t *)(src+0*spitch+3*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src5a = vld1q_u32((uint32_t *)(src+0*spitch+4*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src6a = vld1q_u32((uint32_t *)(src+0*spitch+5*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src7a = vld1q_u32((uint32_t *)(src+0*spitch+6*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src8a = vld1q_u32((uint32_t *)(src+0*spitch+7*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1b = vld1q_u32((uint32_t *)(src+1*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2b = vld1q_u32((uint32_t *)(src+1*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3b = vld1q_u32((uint32_t *)(src+1*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4b = vld1q_u32((uint32_t *)(src+1*spitch+3*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src5b = vld1q_u32((uint32_t *)(src+1*spitch+4*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src6b = vld1q_u32((uint32_t *)(src+1*spitch+5*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src7b = vld1q_u32((uint32_t *)(src+1*spitch+6*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src8b = vld1q_u32((uint32_t *)(src+1*spitch+7*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+0*BYTES_PER_UINT32X4_T),src1a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+1*BYTES_PER_UINT32X4_T),src2a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+2*BYTES_PER_UINT32X4_T),src3a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+3*BYTES_PER_UINT32X4_T),src4a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+4*BYTES_PER_UINT32X4_T),src5a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+5*BYTES_PER_UINT32X4_T),src6a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+6*BYTES_PER_UINT32X4_T),src7a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+7*BYTES_PER_UINT32X4_T),src8a);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+0*BYTES_PER_UINT32X4_T),src1b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+1*BYTES_PER_UINT32X4_T),src2b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+2*BYTES_PER_UINT32X4_T),src3b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+3*BYTES_PER_UINT32X4_T),src4b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+4*BYTES_PER_UINT32X4_T),src5b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+5*BYTES_PER_UINT32X4_T),src6b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+6*BYTES_PER_UINT32X4_T),src7b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+7*BYTES_PER_UINT32X4_T),src8b);
-                  return TRUE;
-               }//HERE
-               else if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,4*BYTES_PER_UINT16_T)) {
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                             src + 0,                             4,    xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*16+4)*BYTES_PER_UINT16_T,   src + (0*16+4)*BYTES_PER_UINT16_T,   2*16, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*16+4)*BYTES_PER_UINT16_T,   src + (2*16+4)*BYTES_PER_UINT16_T,   16,   xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*16+4)*BYTES_PER_UINT16_T,   src + (3*16+4)*BYTES_PER_UINT16_T,   8,    xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (8+3*16+4)*BYTES_PER_UINT16_T, src + (8+3*16+4)*BYTES_PER_UINT16_T, 4,    xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (8+3*16+4)*BYTES_PER_UINT16_T, src + (8+3*16+4)*BYTES_PER_UINT16_T, 4,    xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*16+4)*BYTES_PER_UINT16_T,   src + (3*16+4)*BYTES_PER_UINT16_T,   8,    xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*16+4)*BYTES_PER_UINT16_T,   src + (2*16+4)*BYTES_PER_UINT16_T,   16,   xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*16+4)*BYTES_PER_UINT16_T,   src + (0*16+4)*BYTES_PER_UINT16_T,   2*16, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                             src + 0,                             4,    xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,2*BYTES_PER_UINT16_T)) {
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 2, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+2)*BYTES_PER_UINT16_T, src + (0*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+2)*BYTES_PER_UINT16_T, src + (1*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+2)*BYTES_PER_UINT16_T, src + (2*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+2)*BYTES_PER_UINT16_T, src + (3*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (4*8+2)*BYTES_PER_UINT16_T, src + (4*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (5*8+2)*BYTES_PER_UINT16_T, src + (5*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (6*8+2)*BYTES_PER_UINT16_T, src + (6*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (7*8+2)*BYTES_PER_UINT16_T, src + (7*8+2)*BYTES_PER_UINT16_T, 6, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (7*8+2)*BYTES_PER_UINT16_T, src + (7*8+2)*BYTES_PER_UINT16_T, 6, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (6*8+2)*BYTES_PER_UINT16_T, src + (6*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (5*8+2)*BYTES_PER_UINT16_T, src + (5*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (4*8+2)*BYTES_PER_UINT16_T, src + (4*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+2)*BYTES_PER_UINT16_T, src + (3*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+2)*BYTES_PER_UINT16_T, src + (2*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+2)*BYTES_PER_UINT16_T, src + (1*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+2)*BYTES_PER_UINT16_T, src + (0*8+2)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 2, xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,BYTES_PER_UINT16_T)) {
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 1, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+1)*BYTES_PER_UINT16_T, src + (0*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+1)*BYTES_PER_UINT16_T, src + (1*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+1)*BYTES_PER_UINT16_T, src + (2*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+1)*BYTES_PER_UINT16_T, src + (3*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (4*8+1)*BYTES_PER_UINT16_T, src + (4*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (5*8+1)*BYTES_PER_UINT16_T, src + (5*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (6*8+1)*BYTES_PER_UINT16_T, src + (6*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (7*8+1)*BYTES_PER_UINT16_T, src + (7*8+1)*BYTES_PER_UINT16_T, 7, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (7*8+1)*BYTES_PER_UINT16_T, src + (7*8+1)*BYTES_PER_UINT16_T, 7, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (6*8+1)*BYTES_PER_UINT16_T, src + (6*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (5*8+1)*BYTES_PER_UINT16_T, src + (5*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (4*8+1)*BYTES_PER_UINT16_T, src + (4*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (3*8+1)*BYTES_PER_UINT16_T, src + (3*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (2*8+1)*BYTES_PER_UINT16_T, src + (2*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (1*8+1)*BYTES_PER_UINT16_T, src + (1*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + (0*8+1)*BYTES_PER_UINT16_T, src + (0*8+1)*BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths2Rows_Unaligned(dst + 0,                          src + 0                         , 1, xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               break;
    }
 
    return FALSE;
@@ -1161,484 +586,7 @@ swCopy16BppSmallFixedWidths4Rows_Unaligned(unsigned char *dst, unsigned char *sr
                }
                return TRUE;
                break;
-      case  7: if (xdir >= 0) {
-                  swCopy16BppSmallFixedWidths4Rows_Unaligned(dst, src, 4, xdir, dpitch, spitch);
-                  swCopy16BppSmallFixedWidths4Rows_Unaligned(dst + 4 * BYTES_PER_UINT16_T, src + 4 * BYTES_PER_UINT16_T, 3, xdir, dpitch, spitch);
-               } else {
-                  swCopy16BppSmallFixedWidths4Rows_Unaligned(dst + 4 * BYTES_PER_UINT16_T, src + 4 * BYTES_PER_UINT16_T, 3, xdir, dpitch, spitch);
-                  swCopy16BppSmallFixedWidths4Rows_Unaligned(dst, src, 4, xdir, dpitch, spitch);
-               }
-               return TRUE;
-               break;
-      // TODO: Add more alignment checks for 8 pixel-wide cases for performance reasons?
-      //       For example, handling (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,DOUBLE_WORD_ALIGNMENT_BYTE_SIZE/2)) and related half-aligned cases...
-      case  8: if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32x4_t src1a = vld1q_u32((uint32_t *)(src+0*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1b = vld1q_u32((uint32_t *)(src+1*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1c = vld1q_u32((uint32_t *)(src+2*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1d = vld1q_u32((uint32_t *)(src+3*spitch+0*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+0*BYTES_PER_UINT32X4_T),src1a);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+0*BYTES_PER_UINT32X4_T),src1b);
-                  vst1q_u32((uint32_t *)(dst+2*dpitch+0*BYTES_PER_UINT32X4_T),src1c);
-                  vst1q_u32((uint32_t *)(dst+3*dpitch+0*BYTES_PER_UINT32X4_T),src1d);
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint64_t src1a = *(uint64_t *) (src+0*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2a = *(uint64_t *) (src+0*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src1b = *(uint64_t *) (src+1*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2b = *(uint64_t *) (src+1*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src1c = *(uint64_t *) (src+2*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2c = *(uint64_t *) (src+2*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src1d = *(uint64_t *) (src+3*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2d = *(uint64_t *) (src+3*spitch+1*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*dpitch+0*BYTES_PER_UINT64_T)  = src1a;
-                  *(uint64_t *) (dst+0*dpitch+1*BYTES_PER_UINT64_T)  = src2a;
-                  *(uint64_t *) (dst+1*dpitch+0*BYTES_PER_UINT64_T)  = src1b;
-                  *(uint64_t *) (dst+1*dpitch+1*BYTES_PER_UINT64_T)  = src2b;
-                  *(uint64_t *) (dst+2*dpitch+0*BYTES_PER_UINT64_T)  = src1c;
-                  *(uint64_t *) (dst+2*dpitch+1*BYTES_PER_UINT64_T)  = src2c;
-                  *(uint64_t *) (dst+3*dpitch+0*BYTES_PER_UINT64_T)  = src1d;
-                  *(uint64_t *) (dst+3*dpitch+1*BYTES_PER_UINT64_T)  = src2d;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32_t src1a = *(uint32_t *) (src+0*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2a = *(uint32_t *) (src+0*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3a = *(uint32_t *) (src+0*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4a = *(uint32_t *) (src+0*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src1b = *(uint32_t *) (src+1*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2b = *(uint32_t *) (src+1*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3b = *(uint32_t *) (src+1*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4b = *(uint32_t *) (src+1*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src1c = *(uint32_t *) (src+2*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2c = *(uint32_t *) (src+2*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3c = *(uint32_t *) (src+2*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4c = *(uint32_t *) (src+2*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src1d = *(uint32_t *) (src+3*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2d = *(uint32_t *) (src+3*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3d = *(uint32_t *) (src+3*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4d = *(uint32_t *) (src+3*spitch+3*BYTES_PER_UINT32_T);
-                  *(uint32_t *) (dst+0*dpitch+0*BYTES_PER_UINT32_T)  = src1a;
-                  *(uint32_t *) (dst+0*dpitch+1*BYTES_PER_UINT32_T)  = src2a;
-                  *(uint32_t *) (dst+0*dpitch+2*BYTES_PER_UINT32_T)  = src3a;
-                  *(uint32_t *) (dst+0*dpitch+3*BYTES_PER_UINT32_T)  = src4a;
-                  *(uint32_t *) (dst+1*dpitch+0*BYTES_PER_UINT32_T)  = src1b;
-                  *(uint32_t *) (dst+1*dpitch+1*BYTES_PER_UINT32_T)  = src2b;
-                  *(uint32_t *) (dst+1*dpitch+2*BYTES_PER_UINT32_T)  = src3b;
-                  *(uint32_t *) (dst+1*dpitch+3*BYTES_PER_UINT32_T)  = src4b;
-                  *(uint32_t *) (dst+2*dpitch+0*BYTES_PER_UINT32_T)  = src1c;
-                  *(uint32_t *) (dst+2*dpitch+1*BYTES_PER_UINT32_T)  = src2c;
-                  *(uint32_t *) (dst+2*dpitch+2*BYTES_PER_UINT32_T)  = src3c;
-                  *(uint32_t *) (dst+2*dpitch+3*BYTES_PER_UINT32_T)  = src4c;
-                  *(uint32_t *) (dst+3*dpitch+0*BYTES_PER_UINT32_T)  = src1d;
-                  *(uint32_t *) (dst+3*dpitch+1*BYTES_PER_UINT32_T)  = src2d;
-                  *(uint32_t *) (dst+3*dpitch+2*BYTES_PER_UINT32_T)  = src3d;
-                  *(uint32_t *) (dst+3*dpitch+3*BYTES_PER_UINT32_T)  = src4d;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,BYTES_PER_UINT16_T)) {
-                  uint16_t src1a = *(uint16_t *) (src+0*spitch+0);
-                  uint32_t src2a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint16_t src5a = *(uint16_t *) (src+0*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint16_t src1b = *(uint16_t *) (src+1*spitch+0);
-                  uint32_t src2b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint16_t src5b = *(uint16_t *) (src+1*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint16_t src1c = *(uint16_t *) (src+2*spitch+0);
-                  uint32_t src2c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint16_t src5c = *(uint16_t *) (src+2*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint16_t src1d = *(uint16_t *) (src+3*spitch+0);
-                  uint32_t src2d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint16_t src5d = *(uint16_t *) (src+3*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  *(uint16_t *) (dst+0*dpitch+0)                                        = src1a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4a;
-                  *(uint16_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5a;
-                  *(uint16_t *) (dst+1*dpitch+0)                                        = src1b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4b;
-                  *(uint16_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5b;
-                  *(uint16_t *) (dst+2*dpitch+0)                                        = src1c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4c;
-                  *(uint16_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5c;
-                  *(uint16_t *) (dst+3*dpitch+0)                                        = src1d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4d;
-                  *(uint16_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5d;
-                  return TRUE;
-               }
-               else {
-                  uint16_t src1a = *(uint16_t *) (src+0*spitch+0*BYTES_PER_UINT16_T);
-                  uint16_t src2a = *(uint16_t *) (src+0*spitch+1*BYTES_PER_UINT16_T);
-                  uint16_t src3a = *(uint16_t *) (src+0*spitch+2*BYTES_PER_UINT16_T);
-                  uint16_t src4a = *(uint16_t *) (src+0*spitch+3*BYTES_PER_UINT16_T);
-                  uint16_t src5a = *(uint16_t *) (src+0*spitch+4*BYTES_PER_UINT16_T);
-                  uint16_t src6a = *(uint16_t *) (src+0*spitch+5*BYTES_PER_UINT16_T);
-                  uint16_t src7a = *(uint16_t *) (src+0*spitch+6*BYTES_PER_UINT16_T);
-                  uint16_t src8a = *(uint16_t *) (src+0*spitch+7*BYTES_PER_UINT16_T);
-                  uint16_t src1b = *(uint16_t *) (src+1*spitch+0*BYTES_PER_UINT16_T);
-                  uint16_t src2b = *(uint16_t *) (src+1*spitch+1*BYTES_PER_UINT16_T);
-                  uint16_t src3b = *(uint16_t *) (src+1*spitch+2*BYTES_PER_UINT16_T);
-                  uint16_t src4b = *(uint16_t *) (src+1*spitch+3*BYTES_PER_UINT16_T);
-                  uint16_t src5b = *(uint16_t *) (src+1*spitch+4*BYTES_PER_UINT16_T);
-                  uint16_t src6b = *(uint16_t *) (src+1*spitch+5*BYTES_PER_UINT16_T);
-                  uint16_t src7b = *(uint16_t *) (src+1*spitch+6*BYTES_PER_UINT16_T);
-                  uint16_t src8b = *(uint16_t *) (src+1*spitch+7*BYTES_PER_UINT16_T);
-                  uint16_t src1c = *(uint16_t *) (src+2*spitch+0*BYTES_PER_UINT16_T);
-                  uint16_t src2c = *(uint16_t *) (src+2*spitch+1*BYTES_PER_UINT16_T);
-                  uint16_t src3c = *(uint16_t *) (src+2*spitch+2*BYTES_PER_UINT16_T);
-                  uint16_t src4c = *(uint16_t *) (src+2*spitch+3*BYTES_PER_UINT16_T);
-                  uint16_t src5c = *(uint16_t *) (src+2*spitch+4*BYTES_PER_UINT16_T);
-                  uint16_t src6c = *(uint16_t *) (src+2*spitch+5*BYTES_PER_UINT16_T);
-                  uint16_t src7c = *(uint16_t *) (src+2*spitch+6*BYTES_PER_UINT16_T);
-                  uint16_t src8c = *(uint16_t *) (src+2*spitch+7*BYTES_PER_UINT16_T);
-                  uint16_t src1d = *(uint16_t *) (src+3*spitch+0*BYTES_PER_UINT16_T);
-                  uint16_t src2d = *(uint16_t *) (src+3*spitch+1*BYTES_PER_UINT16_T);
-                  uint16_t src3d = *(uint16_t *) (src+3*spitch+2*BYTES_PER_UINT16_T);
-                  uint16_t src4d = *(uint16_t *) (src+3*spitch+3*BYTES_PER_UINT16_T);
-                  uint16_t src5d = *(uint16_t *) (src+3*spitch+4*BYTES_PER_UINT16_T);
-                  uint16_t src6d = *(uint16_t *) (src+3*spitch+5*BYTES_PER_UINT16_T);
-                  uint16_t src7d = *(uint16_t *) (src+3*spitch+6*BYTES_PER_UINT16_T);
-                  uint16_t src8d = *(uint16_t *) (src+3*spitch+7*BYTES_PER_UINT16_T);
-                  *(uint16_t *) (dst+0*dpitch+0*BYTES_PER_UINT16_T)  = src1a;
-                  *(uint16_t *) (dst+0*dpitch+1*BYTES_PER_UINT16_T)  = src2a;
-                  *(uint16_t *) (dst+0*dpitch+2*BYTES_PER_UINT16_T)  = src3a;
-                  *(uint16_t *) (dst+0*dpitch+3*BYTES_PER_UINT16_T)  = src4a;
-                  *(uint16_t *) (dst+0*dpitch+4*BYTES_PER_UINT16_T)  = src5a;
-                  *(uint16_t *) (dst+0*dpitch+5*BYTES_PER_UINT16_T)  = src6a;
-                  *(uint16_t *) (dst+0*dpitch+6*BYTES_PER_UINT16_T)  = src7a;
-                  *(uint16_t *) (dst+0*dpitch+7*BYTES_PER_UINT16_T)  = src8a;
-                  *(uint16_t *) (dst+1*dpitch+0*BYTES_PER_UINT16_T)  = src1b;
-                  *(uint16_t *) (dst+1*dpitch+1*BYTES_PER_UINT16_T)  = src2b;
-                  *(uint16_t *) (dst+1*dpitch+2*BYTES_PER_UINT16_T)  = src3b;
-                  *(uint16_t *) (dst+1*dpitch+3*BYTES_PER_UINT16_T)  = src4b;
-                  *(uint16_t *) (dst+1*dpitch+4*BYTES_PER_UINT16_T)  = src5b;
-                  *(uint16_t *) (dst+1*dpitch+5*BYTES_PER_UINT16_T)  = src6b;
-                  *(uint16_t *) (dst+1*dpitch+6*BYTES_PER_UINT16_T)  = src7b;
-                  *(uint16_t *) (dst+1*dpitch+7*BYTES_PER_UINT16_T)  = src8b;
-                  *(uint16_t *) (dst+2*dpitch+0*BYTES_PER_UINT16_T)  = src1c;
-                  *(uint16_t *) (dst+2*dpitch+1*BYTES_PER_UINT16_T)  = src2c;
-                  *(uint16_t *) (dst+2*dpitch+2*BYTES_PER_UINT16_T)  = src3c;
-                  *(uint16_t *) (dst+2*dpitch+3*BYTES_PER_UINT16_T)  = src4c;
-                  *(uint16_t *) (dst+2*dpitch+4*BYTES_PER_UINT16_T)  = src5c;
-                  *(uint16_t *) (dst+2*dpitch+5*BYTES_PER_UINT16_T)  = src6c;
-                  *(uint16_t *) (dst+2*dpitch+6*BYTES_PER_UINT16_T)  = src7c;
-                  *(uint16_t *) (dst+2*dpitch+7*BYTES_PER_UINT16_T)  = src8c;
-                  *(uint16_t *) (dst+3*dpitch+0*BYTES_PER_UINT16_T)  = src1d;
-                  *(uint16_t *) (dst+3*dpitch+1*BYTES_PER_UINT16_T)  = src2d;
-                  *(uint16_t *) (dst+3*dpitch+2*BYTES_PER_UINT16_T)  = src3d;
-                  *(uint16_t *) (dst+3*dpitch+3*BYTES_PER_UINT16_T)  = src4d;
-                  *(uint16_t *) (dst+3*dpitch+4*BYTES_PER_UINT16_T)  = src5d;
-                  *(uint16_t *) (dst+3*dpitch+5*BYTES_PER_UINT16_T)  = src6d;
-                  *(uint16_t *) (dst+3*dpitch+6*BYTES_PER_UINT16_T)  = src7d;
-                  *(uint16_t *) (dst+3*dpitch+7*BYTES_PER_UINT16_T)  = src8d;
-                  return TRUE;
-               }
-               break;
-      case 16: if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32x4_t src1a = vld1q_u32((uint32_t *)(src+0*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2a = vld1q_u32((uint32_t *)(src+0*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1b = vld1q_u32((uint32_t *)(src+1*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2b = vld1q_u32((uint32_t *)(src+1*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1c = vld1q_u32((uint32_t *)(src+2*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2c = vld1q_u32((uint32_t *)(src+2*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1d = vld1q_u32((uint32_t *)(src+3*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2d = vld1q_u32((uint32_t *)(src+3*spitch+1*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+0*BYTES_PER_UINT32X4_T),src1a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+1*BYTES_PER_UINT32X4_T),src2a);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+0*BYTES_PER_UINT32X4_T),src1b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+1*BYTES_PER_UINT32X4_T),src2b);
-                  vst1q_u32((uint32_t *)(dst+2*dpitch+0*BYTES_PER_UINT32X4_T),src1c);
-                  vst1q_u32((uint32_t *)(dst+2*dpitch+1*BYTES_PER_UINT32X4_T),src2c);
-                  vst1q_u32((uint32_t *)(dst+3*dpitch+0*BYTES_PER_UINT32X4_T),src1d);
-                  vst1q_u32((uint32_t *)(dst+3*dpitch+1*BYTES_PER_UINT32X4_T),src2d);
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint64_t src1a = *(uint64_t *) (src+0*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2a = *(uint64_t *) (src+0*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3a = *(uint64_t *) (src+0*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4a = *(uint64_t *) (src+0*spitch+3*BYTES_PER_UINT64_T);
-                  uint64_t src1b = *(uint64_t *) (src+1*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2b = *(uint64_t *) (src+1*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3b = *(uint64_t *) (src+1*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4b = *(uint64_t *) (src+1*spitch+3*BYTES_PER_UINT64_T);
-                  uint64_t src1c = *(uint64_t *) (src+2*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2c = *(uint64_t *) (src+2*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3c = *(uint64_t *) (src+2*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4c = *(uint64_t *) (src+2*spitch+3*BYTES_PER_UINT64_T);
-                  uint64_t src1d = *(uint64_t *) (src+3*spitch+0*BYTES_PER_UINT64_T);
-                  uint64_t src2d = *(uint64_t *) (src+3*spitch+1*BYTES_PER_UINT64_T);
-                  uint64_t src3d = *(uint64_t *) (src+3*spitch+2*BYTES_PER_UINT64_T);
-                  uint64_t src4d = *(uint64_t *) (src+3*spitch+3*BYTES_PER_UINT64_T);
-                  *(uint64_t *) (dst+0*dpitch+0*BYTES_PER_UINT64_T)  = src1a;
-                  *(uint64_t *) (dst+0*dpitch+1*BYTES_PER_UINT64_T)  = src2a;
-                  *(uint64_t *) (dst+0*dpitch+2*BYTES_PER_UINT64_T)  = src3a;
-                  *(uint64_t *) (dst+0*dpitch+3*BYTES_PER_UINT64_T)  = src4a;
-                  *(uint64_t *) (dst+1*dpitch+0*BYTES_PER_UINT64_T)  = src1b;
-                  *(uint64_t *) (dst+1*dpitch+1*BYTES_PER_UINT64_T)  = src2b;
-                  *(uint64_t *) (dst+1*dpitch+2*BYTES_PER_UINT64_T)  = src3b;
-                  *(uint64_t *) (dst+1*dpitch+3*BYTES_PER_UINT64_T)  = src4b;
-                  *(uint64_t *) (dst+2*dpitch+0*BYTES_PER_UINT64_T)  = src1c;
-                  *(uint64_t *) (dst+2*dpitch+1*BYTES_PER_UINT64_T)  = src2c;
-                  *(uint64_t *) (dst+2*dpitch+2*BYTES_PER_UINT64_T)  = src3c;
-                  *(uint64_t *) (dst+2*dpitch+3*BYTES_PER_UINT64_T)  = src4c;
-                  *(uint64_t *) (dst+3*dpitch+0*BYTES_PER_UINT64_T)  = src1d;
-                  *(uint64_t *) (dst+3*dpitch+1*BYTES_PER_UINT64_T)  = src2d;
-                  *(uint64_t *) (dst+3*dpitch+2*BYTES_PER_UINT64_T)  = src3d;
-                  *(uint64_t *) (dst+3*dpitch+3*BYTES_PER_UINT64_T)  = src4d;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,2*BYTES_PER_UINT16_T)) {
-                  uint32_t src1a = *(uint32_t *) (src+0*spitch+0);
-                  uint64_t src2a = *(uint64_t *) (src+0*spitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T);
-                  uint64_t src3a = *(uint64_t *) (src+0*spitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T);
-                  uint64_t src4a = *(uint64_t *) (src+0*spitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T);
-                  uint32_t src5a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T);
-                  uint32_t src1b = *(uint32_t *) (src+1*spitch+0);
-                  uint64_t src2b = *(uint64_t *) (src+1*spitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T);
-                  uint64_t src3b = *(uint64_t *) (src+1*spitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T);
-                  uint64_t src4b = *(uint64_t *) (src+1*spitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T);
-                  uint32_t src5b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T);
-                  uint32_t src1c = *(uint32_t *) (src+2*spitch+0);
-                  uint64_t src2c = *(uint64_t *) (src+2*spitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T);
-                  uint64_t src3c = *(uint64_t *) (src+2*spitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T);
-                  uint64_t src4c = *(uint64_t *) (src+2*spitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T);
-                  uint32_t src5c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T);
-                  uint32_t src1d = *(uint32_t *) (src+3*spitch+0);
-                  uint64_t src2d = *(uint64_t *) (src+3*spitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T);
-                  uint64_t src3d = *(uint64_t *) (src+3*spitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T);
-                  uint64_t src4d = *(uint64_t *) (src+3*spitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T);
-                  uint32_t src5d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T);
-                  *(uint32_t *) (dst+0*dpitch+0)                                        = src1a;
-                  *(uint64_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T)  = src2a;
-                  *(uint64_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T)  = src3a;
-                  *(uint64_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T)  = src4a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T)  = src5a;
-                  *(uint32_t *) (dst+1*dpitch+0)                                        = src1b;
-                  *(uint64_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T)  = src2b;
-                  *(uint64_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T)  = src3b;
-                  *(uint64_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T)  = src4b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T)  = src5b;
-                  *(uint32_t *) (dst+2*dpitch+0)                                        = src1c;
-                  *(uint64_t *) (dst+2*dpitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T)  = src2c;
-                  *(uint64_t *) (dst+2*dpitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T)  = src3c;
-                  *(uint64_t *) (dst+2*dpitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T)  = src4c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T)  = src5c;
-                  *(uint32_t *) (dst+3*dpitch+0)                                        = src1d;
-                  *(uint64_t *) (dst+3*dpitch+BYTES_PER_UINT32_T+0*BYTES_PER_UINT64_T)  = src2d;
-                  *(uint64_t *) (dst+3*dpitch+BYTES_PER_UINT32_T+1*BYTES_PER_UINT64_T)  = src3d;
-                  *(uint64_t *) (dst+3*dpitch+BYTES_PER_UINT32_T+2*BYTES_PER_UINT64_T)  = src4d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT32_T+3*BYTES_PER_UINT64_T)  = src5d;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32_t src1a = *(uint32_t *) (src+0*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2a = *(uint32_t *) (src+0*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3a = *(uint32_t *) (src+0*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4a = *(uint32_t *) (src+0*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src5a = *(uint32_t *) (src+0*spitch+4*BYTES_PER_UINT32_T);
-                  uint32_t src6a = *(uint32_t *) (src+0*spitch+5*BYTES_PER_UINT32_T);
-                  uint32_t src7a = *(uint32_t *) (src+0*spitch+6*BYTES_PER_UINT32_T);
-                  uint32_t src8a = *(uint32_t *) (src+0*spitch+7*BYTES_PER_UINT32_T);
-                  uint32_t src1b = *(uint32_t *) (src+1*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2b = *(uint32_t *) (src+1*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3b = *(uint32_t *) (src+1*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4b = *(uint32_t *) (src+1*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src5b = *(uint32_t *) (src+1*spitch+4*BYTES_PER_UINT32_T);
-                  uint32_t src6b = *(uint32_t *) (src+1*spitch+5*BYTES_PER_UINT32_T);
-                  uint32_t src7b = *(uint32_t *) (src+1*spitch+6*BYTES_PER_UINT32_T);
-                  uint32_t src8b = *(uint32_t *) (src+1*spitch+7*BYTES_PER_UINT32_T);
-                  uint32_t src1c = *(uint32_t *) (src+2*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2c = *(uint32_t *) (src+2*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3c = *(uint32_t *) (src+2*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4c = *(uint32_t *) (src+2*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src5c = *(uint32_t *) (src+2*spitch+4*BYTES_PER_UINT32_T);
-                  uint32_t src6c = *(uint32_t *) (src+2*spitch+5*BYTES_PER_UINT32_T);
-                  uint32_t src7c = *(uint32_t *) (src+2*spitch+6*BYTES_PER_UINT32_T);
-                  uint32_t src8c = *(uint32_t *) (src+2*spitch+7*BYTES_PER_UINT32_T);
-                  uint32_t src1d = *(uint32_t *) (src+3*spitch+0*BYTES_PER_UINT32_T);
-                  uint32_t src2d = *(uint32_t *) (src+3*spitch+1*BYTES_PER_UINT32_T);
-                  uint32_t src3d = *(uint32_t *) (src+3*spitch+2*BYTES_PER_UINT32_T);
-                  uint32_t src4d = *(uint32_t *) (src+3*spitch+3*BYTES_PER_UINT32_T);
-                  uint32_t src5d = *(uint32_t *) (src+3*spitch+4*BYTES_PER_UINT32_T);
-                  uint32_t src6d = *(uint32_t *) (src+3*spitch+5*BYTES_PER_UINT32_T);
-                  uint32_t src7d = *(uint32_t *) (src+3*spitch+6*BYTES_PER_UINT32_T);
-                  uint32_t src8d = *(uint32_t *) (src+3*spitch+7*BYTES_PER_UINT32_T);
-                  *(uint32_t *) (dst+0*dpitch+0*BYTES_PER_UINT32_T)  = src1a;
-                  *(uint32_t *) (dst+0*dpitch+1*BYTES_PER_UINT32_T)  = src2a;
-                  *(uint32_t *) (dst+0*dpitch+2*BYTES_PER_UINT32_T)  = src3a;
-                  *(uint32_t *) (dst+0*dpitch+3*BYTES_PER_UINT32_T)  = src4a;
-                  *(uint32_t *) (dst+0*dpitch+4*BYTES_PER_UINT32_T)  = src5a;
-                  *(uint32_t *) (dst+0*dpitch+5*BYTES_PER_UINT32_T)  = src6a;
-                  *(uint32_t *) (dst+0*dpitch+6*BYTES_PER_UINT32_T)  = src7a;
-                  *(uint32_t *) (dst+0*dpitch+7*BYTES_PER_UINT32_T)  = src8a;
-                  *(uint32_t *) (dst+1*dpitch+0*BYTES_PER_UINT32_T)  = src1b;
-                  *(uint32_t *) (dst+1*dpitch+1*BYTES_PER_UINT32_T)  = src2b;
-                  *(uint32_t *) (dst+1*dpitch+2*BYTES_PER_UINT32_T)  = src3b;
-                  *(uint32_t *) (dst+1*dpitch+3*BYTES_PER_UINT32_T)  = src4b;
-                  *(uint32_t *) (dst+1*dpitch+4*BYTES_PER_UINT32_T)  = src5b;
-                  *(uint32_t *) (dst+1*dpitch+5*BYTES_PER_UINT32_T)  = src6b;
-                  *(uint32_t *) (dst+1*dpitch+6*BYTES_PER_UINT32_T)  = src7b;
-                  *(uint32_t *) (dst+1*dpitch+7*BYTES_PER_UINT32_T)  = src8b;
-                  *(uint32_t *) (dst+2*dpitch+0*BYTES_PER_UINT32_T)  = src1c;
-                  *(uint32_t *) (dst+2*dpitch+1*BYTES_PER_UINT32_T)  = src2c;
-                  *(uint32_t *) (dst+2*dpitch+2*BYTES_PER_UINT32_T)  = src3c;
-                  *(uint32_t *) (dst+2*dpitch+3*BYTES_PER_UINT32_T)  = src4c;
-                  *(uint32_t *) (dst+2*dpitch+4*BYTES_PER_UINT32_T)  = src5c;
-                  *(uint32_t *) (dst+2*dpitch+5*BYTES_PER_UINT32_T)  = src6c;
-                  *(uint32_t *) (dst+2*dpitch+6*BYTES_PER_UINT32_T)  = src7c;
-                  *(uint32_t *) (dst+2*dpitch+7*BYTES_PER_UINT32_T)  = src8c;
-                  *(uint32_t *) (dst+3*dpitch+0*BYTES_PER_UINT32_T)  = src1d;
-                  *(uint32_t *) (dst+3*dpitch+1*BYTES_PER_UINT32_T)  = src2d;
-                  *(uint32_t *) (dst+3*dpitch+2*BYTES_PER_UINT32_T)  = src3d;
-                  *(uint32_t *) (dst+3*dpitch+3*BYTES_PER_UINT32_T)  = src4d;
-                  *(uint32_t *) (dst+3*dpitch+4*BYTES_PER_UINT32_T)  = src5d;
-                  *(uint32_t *) (dst+3*dpitch+5*BYTES_PER_UINT32_T)  = src6d;
-                  *(uint32_t *) (dst+3*dpitch+6*BYTES_PER_UINT32_T)  = src7d;
-                  *(uint32_t *) (dst+3*dpitch+7*BYTES_PER_UINT32_T)  = src8d;
-                  return TRUE;
-               }
-               else if (SW_CHECK_PITCHED_ALIGNMENT(WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,BYTES_PER_UINT16_T)) {
-                  uint16_t src1a = *(uint16_t *) (src+0*spitch+0);
-                  uint32_t src2a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint32_t src5a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint32_t src6a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T);
-                  uint32_t src7a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T);
-                  uint32_t src8a = *(uint32_t *) (src+0*spitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T);
-                  uint16_t src9a = *(uint16_t *) (src+0*spitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T);
-                  uint16_t src1b = *(uint16_t *) (src+1*spitch+0);
-                  uint32_t src2b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint32_t src5b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint32_t src6b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T);
-                  uint32_t src7b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T);
-                  uint32_t src8b = *(uint32_t *) (src+1*spitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T);
-                  uint16_t src9b = *(uint16_t *) (src+1*spitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T);
-                  uint16_t src1c = *(uint16_t *) (src+2*spitch+0);
-                  uint32_t src2c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint32_t src5c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint32_t src6c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T);
-                  uint32_t src7c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T);
-                  uint32_t src8c = *(uint32_t *) (src+2*spitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T);
-                  uint16_t src9c = *(uint16_t *) (src+2*spitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T);
-                  uint16_t src1d = *(uint16_t *) (src+3*spitch+0);
-                  uint32_t src2d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T);
-                  uint32_t src3d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T);
-                  uint32_t src4d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T);
-                  uint32_t src5d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T);
-                  uint32_t src6d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T);
-                  uint32_t src7d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T);
-                  uint32_t src8d = *(uint32_t *) (src+3*spitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T);
-                  uint16_t src9d = *(uint16_t *) (src+3*spitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T);
-                  *(uint16_t *) (dst+0*dpitch+0)                                        = src1a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T)  = src6a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T)  = src7a;
-                  *(uint32_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T)  = src8a;
-                  *(uint16_t *) (dst+0*dpitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T)  = src9a;
-                  *(uint16_t *) (dst+1*dpitch+0)                                        = src1b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T)  = src6b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T)  = src7b;
-                  *(uint32_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T)  = src8b;
-                  *(uint16_t *) (dst+1*dpitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T)  = src9b;
-                  *(uint16_t *) (dst+2*dpitch+0)                                        = src1c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T)  = src6c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T)  = src7c;
-                  *(uint32_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T)  = src8c;
-                  *(uint16_t *) (dst+2*dpitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T)  = src9c;
-                  *(uint16_t *) (dst+3*dpitch+0)                                        = src1d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+0*BYTES_PER_UINT32_T)  = src2d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+1*BYTES_PER_UINT32_T)  = src3d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+2*BYTES_PER_UINT32_T)  = src4d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+3*BYTES_PER_UINT32_T)  = src5d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+4*BYTES_PER_UINT32_T)  = src6d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+5*BYTES_PER_UINT32_T)  = src7d;
-                  *(uint32_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+6*BYTES_PER_UINT32_T)  = src8d;
-                  *(uint16_t *) (dst+3*dpitch+BYTES_PER_UINT16_T+7*BYTES_PER_UINT32_T)  = src9d;
-                  return TRUE;
-               }
-               else {
-                  // Don't bother unrolling loops, since that won't help for more than around 8 operations.
-                  // Instead, just call multiple fixed functions.
-                  if (xdir >= 0) {
-                     swCopy16BppSmallFixedWidths4Rows_Unaligned(dst, src, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths4Rows_Unaligned(dst + 8 * BYTES_PER_UINT16_T, src + 8 * BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                  } else {
-                     swCopy16BppSmallFixedWidths4Rows_Unaligned(dst + 8 * BYTES_PER_UINT16_T, src + 8 * BYTES_PER_UINT16_T, 8, xdir, dpitch, spitch);
-                     swCopy16BppSmallFixedWidths4Rows_Unaligned(dst, src, 8, xdir, dpitch, spitch);
-                  }
-                  return TRUE;
-               }
-               break;
-      // TODO: Add more alignment checks for 32 pixel-wide cases for performance reasons?
-      //       For example, handling (SW_CHECK_PITCHED_ALIGNMENT(DOUBLE_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,XXX)) and related cases could make a big difference here...
-      case 32: if (SW_CHECK_PITCHED_ALIGNMENT(QUAD_WORD_ALIGNMENT_BYTE_SIZE,dst,src,dpitch,spitch,0)) {
-                  uint32x4_t src1a = vld1q_u32((uint32_t *)(src+0*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2a = vld1q_u32((uint32_t *)(src+0*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3a = vld1q_u32((uint32_t *)(src+0*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4a = vld1q_u32((uint32_t *)(src+0*spitch+3*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1b = vld1q_u32((uint32_t *)(src+1*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2b = vld1q_u32((uint32_t *)(src+1*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3b = vld1q_u32((uint32_t *)(src+1*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4b = vld1q_u32((uint32_t *)(src+1*spitch+3*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1c = vld1q_u32((uint32_t *)(src+2*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2c = vld1q_u32((uint32_t *)(src+2*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3c = vld1q_u32((uint32_t *)(src+2*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4c = vld1q_u32((uint32_t *)(src+2*spitch+3*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src1d = vld1q_u32((uint32_t *)(src+3*spitch+0*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src2d = vld1q_u32((uint32_t *)(src+3*spitch+1*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src3d = vld1q_u32((uint32_t *)(src+3*spitch+2*BYTES_PER_UINT32X4_T));
-                  uint32x4_t src4d = vld1q_u32((uint32_t *)(src+3*spitch+3*BYTES_PER_UINT32X4_T));
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+0*BYTES_PER_UINT32X4_T),src1a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+1*BYTES_PER_UINT32X4_T),src2a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+2*BYTES_PER_UINT32X4_T),src3a);
-                  vst1q_u32((uint32_t *)(dst+0*dpitch+3*BYTES_PER_UINT32X4_T),src4a);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+0*BYTES_PER_UINT32X4_T),src1b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+1*BYTES_PER_UINT32X4_T),src2b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+2*BYTES_PER_UINT32X4_T),src3b);
-                  vst1q_u32((uint32_t *)(dst+1*dpitch+3*BYTES_PER_UINT32X4_T),src4b);
-                  vst1q_u32((uint32_t *)(dst+2*dpitch+0*BYTES_PER_UINT32X4_T),src1c);
-                  vst1q_u32((uint32_t *)(dst+2*dpitch+1*BYTES_PER_UINT32X4_T),src2c);
-                  vst1q_u32((uint32_t *)(dst+2*dpitch+2*BYTES_PER_UINT32X4_T),src3c);
-                  vst1q_u32((uint32_t *)(dst+2*dpitch+3*BYTES_PER_UINT32X4_T),src4c);
-                  vst1q_u32((uint32_t *)(dst+3*dpitch+0*BYTES_PER_UINT32X4_T),src1d);
-                  vst1q_u32((uint32_t *)(dst+3*dpitch+1*BYTES_PER_UINT32X4_T),src2d);
-                  vst1q_u32((uint32_t *)(dst+3*dpitch+2*BYTES_PER_UINT32X4_T),src3d);
-                  vst1q_u32((uint32_t *)(dst+3*dpitch+3*BYTES_PER_UINT32X4_T),src4d);
-                  return TRUE;
-               }
-               break;
-   }
+         }
 
    return FALSE;
 }
@@ -1924,10 +872,12 @@ swCopyRect16BppFixedWidth_Unaligned(unsigned char *dst, unsigned char *src, int
       if (rowsOverlap)
       {
          if (w > 64) {
-            DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY_NO_NARROW_COPIES(neon_memmove, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+            //DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY_NO_NARROW_COPIES(neon_memmove, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+	    DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY_NO_NARROW_COPIES(memmove, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
          }
          else if (w == 64) {
-            DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(neon_memmove, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+            //DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(neon_memmove, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+	    DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(memmove, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
          }
          else {
             DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(memmove, SIGNAL_BLOCK_NOOP, SIGNAL_BLOCK_NOOP);
@@ -1936,10 +886,12 @@ swCopyRect16BppFixedWidth_Unaligned(unsigned char *dst, unsigned char *src, int
       else
       {
          if (w > 64) {
-            DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY_NO_NARROW_COPIES(neon_memcpy, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+            //DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY_NO_NARROW_COPIES(neon_memcpy, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+	    DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY_NO_NARROW_COPIES(memcpy, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
          }
          else if (w == 64) {
-            DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(neon_memcpy, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+            //DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(neon_memcpy, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
+	    DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(memcpy, BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS, UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS);
          }
          else {
             DRAW_MULTIPLE_ROWS_WITH_MEMORY_COPY(memcpy, SIGNAL_BLOCK_NOOP, SIGNAL_BLOCK_NOOP);
@@ -1973,7 +925,8 @@ swCopyRect8Bpp_Unaligned(unsigned char *dst, unsigned char *src, int w, int h, i
       if (xdir >= 0 || !rowsOverlap) {
          if (w >= 128) {
             BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS();
-            neon_memcpy(dst, src, w);
+            //neon_memcpy(dst, src, w);
+	    memcpy(dst, src, w);
             UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS();
          }
          else
@@ -1982,7 +935,8 @@ swCopyRect8Bpp_Unaligned(unsigned char *dst, unsigned char *src, int w, int h, i
       else {
          if (w >= 128) {
             BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS();
-            neon_memmove(dst, src, w);
+            //neon_memmove(dst, src, w);
+	    memmove(dst, src, w);
             UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS();
          }
          else
@@ -2029,7 +983,8 @@ swCopyRect24Bpp_Unaligned(unsigned char *dst, unsigned char *src, int w, int h,
       if (xdir >= 0 || !rowsOverlap) {
          if (w >= 42) {
             BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS();
-            neon_memcpy(dst, src,  w * BYTES_PER_24BPP_PIXEL);
+            //neon_memcpy(dst, src,  w * BYTES_PER_24BPP_PIXEL);
+	    memcpy(dst, src,  w * BYTES_PER_24BPP_PIXEL);
             UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS();
          }
          else
@@ -2038,7 +993,8 @@ swCopyRect24Bpp_Unaligned(unsigned char *dst, unsigned char *src, int w, int h,
       else {
          if (w >= 42) {
             BLOCK_SIGNALS_BEFORE_VFP_OPERATIONS();
-            neon_memmove(dst, src,  w * BYTES_PER_24BPP_PIXEL);
+            //neon_memmove(dst, src,  w * BYTES_PER_24BPP_PIXEL);
+	    memmove(dst, src,  w * BYTES_PER_24BPP_PIXEL);
             UNBLOCK_SIGNALS_AFTER_VFP_OPERATIONS();
          }
          else
diff --git git/src/neon_memcpy.S git/src/neon_memcpy.S
deleted file mode 100644
index 5ecc5ce..0000000
--- git/src/neon_memcpy.S
+++ /dev/null
@@ -1,549 +0,0 @@
-/***************************************************************************
- Copyright (c) 2009, Code Aurora Forum. All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-     * Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-     * Redistributions in binary form must reproduce the above copyright
-       notice, this list of conditions and the following disclaimer in the
-       documentation and/or other materials provided with the distribution.
-     * Neither the name of Code Aurora nor the names of its contributors may
-       be used to endorse or promote products derived from this software
-       without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
- ***************************************************************************/
-
-/***************************************************************************
-  Neon memcpy: Attempts to do a memcpy with Neon registers if possible,
-     Inputs:
-        dest: The destination buffer
-        src: The source buffer
-        n: The size of the buffer to transfer
-     Outputs:
-
-***************************************************************************/
-
-/*
- * General note:
- * The original code that was compiled for rvct used PUSH/POP and VPUSH/VPOP
- * However, it looks like the 2006 CodeSourcery Assembler has issues generating
- * the correct object code for VPOP, resulting in horrific stack crashes.
- * As a result, I've temporarily move PUSH->STMDB, POP->LDMIA, VPUSH->VSTMDB,
- * and VPOP->VLDMIA.  We can revert this back once we update our toolchain.
- *
- * Also, VSHL swaps the source register and the shift-amount register
- * around in 2006-q3.  I've coded this incorrectly so it turns out correct
- * in the object code, but we'll need to undo that later...
- */
-
-	.code 32
-	.align 4
-	.globl neon_memcpy
-	.func
-
-neon_memcpy:
-	/* 
-	 * First, make sure we're not copying < 4 bytes.  If so, we'll
-         * just handle it here.
-	 */
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r0}
-#else
-	push		{r0}
-#endif
-	cmp		r2, #4
-	bgt		neon_gt_4
-	/* Copy 0-4 bytes, if needed, and return.*/
-	cmp		r2, #0
-neon_smallcopy_loop:
-	beq		neon_smallcopy_done
-	ldrb		r12, [r1], #1
-	subs		r2, r2, #1
-	strb		r12, [r0], #1
-	b		neon_smallcopy_loop
-neon_smallcopy_done:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r0}
-#else
-	pop		{r0}
-#endif
-	bx		lr
-
-	/* Copy 4 or more bytes*/
-neon_gt_4:
-	/* Preload what we can...*/
-	pld		[r0,#0]
-	pld		[r1,#0]
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r4-r5}
-#else
-	push		{r4-r5}
-#endif
-
-neon_check_align:
-	/* Check normal word alignment for target. */
-	ands		r12, r0, #0x3
-	beq		source_alignment_check
-	
-	/*
-	 * Target is not aligned.  Step through until we get that
-	 * word-aligned.  This works better than a loop, according
-	 * to our pipeline modeler.
-	 */
-	cmp		r12, #2
-	ldrb		r3, [r1], #1
-	ldrleb		r4, [r1], #1
-	ldrltb		r5, [r1], #1
-	rsb		r12, r12, #4
-	sub		r2, r2, r12
-	strb		r3, [r0], #1
-	strleb		r4, [r0], #1
-	strltb		r5, [r0], #1
-	
-source_alignment_check:
-	ands		r12, r1, #0x3
-	bne		neon_memcpy_nonaligned	/* Source is not word aligned.*/
-neon_try_16_align:
-	cmp		r2, #64
-	blt		neon_align_route
-	/* This is where we try 16-byte alignment. */
-	ands		r12, r0, #0xf
-	beq		neon_align_route
-	rsb		r12, r12, #16
-neon_16_start:
-	sub		r2, r2, r12
-	lsrs		r3, r12, #2
-neon_align_16_4:
-	ldr		r4, [r1], #4
-	subs		r3, r3, #1
-	str		r4, [r0], #4
-	bne		neon_align_16_4
-neon_align_route:
-	/* In this case, both source and target are word-aligned. */
-	cmp		r2, #32768
-	bge		neon_copy_128p_a
-	cmp		r2, #256
-	bge		neon_copy_128_a
-	cmp		r2, #64
-	bge		neon_copy_32_a
-	b		neon_copy_finish_a
-	nop
-neon_copy_128p_a:
-	/* We'll copy blocks 128-bytes at a time, but try to call pld to
-	 * load in the next page, if possible.
-	 */
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4-q7}
-#else
-	vpush		{q4-q7}
-#endif
-	mov		r12, r2, lsr #7
-neon_copy_128p_loop_a:
-	vld1.32		{q0, q1}, [r1]!
-	vld1.32		{q2, q3}, [r1]!
-	vld1.32		{q4, q5}, [r1]!
-	vld1.32		{q6, q7}, [r1]!
-	pld		[r1, #0]
-	pld		[r1, #1024]
-	vst1.32		{q0, q1}, [r0]!
-	vst1.32		{q2, q3}, [r0]!
-	vst1.32		{q4, q5}, [r0]!
-	vst1.32		{q6, q7}, [r0]!
-	subs		r12, r12, #1
-	bne		neon_copy_128p_loop_a
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q4-q7}
-#else
-	vpop		{q4-q7}
-#endif
-	ands		r2, r2, #0x7f
-	beq		neon_end
-	cmp		r2, #32
-	blt		neon_copy_finish_a
-	b		neon_copy_32_a
-	/* Copy blocks of 128-bytes (word-aligned) at a time*/
-neon_copy_128_a:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4-q7}
-#else
-	vpush		{q4-q7}
-#endif
-	/*
-	 * Move to a 1-s based countdown to determine when to loop.  That
-	 * allows the subs to set the Z flag without having to explicitly
-	 * call cmp to a value.
-	 */
-	mov		r12, r2, lsr #7
-neon_copy_128_loop_a:
-	vld1.32		{q0, q1}, [r1]!
-	vld1.32		{q2, q3}, [r1]!
-	vld1.32		{q4, q5}, [r1]!
-	vld1.32		{q6, q7}, [r1]!
-	pld		[r1, #0]
-	pld		[r1, #128]
-	vst1.32		{q0, q1}, [r0]!
-	vst1.32		{q2, q3}, [r0]!
-	vst1.32		{q4, q5}, [r0]!
-	vst1.32		{q6, q7}, [r0]!
-	subs		r12, r12, #1
-	pld		[r0, #0]
-	pld		[r0, #128]
-	bne		neon_copy_128_loop_a
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q4-q7}
-#else
-	vpop		{q4-q7}
-#endif
-	ands		r2, r2, #0x7f
-	beq		neon_end
-	cmp		r2, #32
-	blt		neon_copy_finish_a
-	/* Copy blocks of 32-bytes (word aligned) at a time*/
-neon_copy_32_a:
-	mov		r12, r2, lsr #5
-neon_copy_32_loop_a:
-	vld1.32		{q0,q1}, [r1]!
-	subs		r12, r12, #1
-	pld		[r1,#0]
-	vst1.32		{q0,q1}, [r0]!
-	bne		neon_copy_32_loop_a
-	ands		r2, r2, #0x1f
-	beq		neon_end
-neon_copy_finish_a:
-neon_copy_16_a:
-	movs		r12, r2, lsr #4
-	beq		neon_copy_8_a
-neon_copy_16_a_loop:
-	vld1.32		{q0}, [r1]!
-	subs		r12, r12, #1
-	vst1.32		{q0}, [r0]!
-	bne		neon_copy_16_a_loop
-	ands		r2, r2, #0xf
-	beq		neon_end
-neon_copy_8_a:
-	cmp		r2, #8
-	blt		neon_copy_4_a
-	ldm		r1!, {r4-r5}
-	subs		r2, r2, #8
-	stm		r0!, {r4-r5}
-	/* Copy 4-bytes of word-aligned data at a time*/
-neon_copy_4_a:
-	cmp		r2, #4
-	blt		neon_copy_finish
-	ldr		r4, [r1], #4
-	subs		r2, r2, #4
-	str		r4, [r0], #4
-	b		neon_copy_finish
-
-	/*
-	 * Handle unaligned data.  The basic concept here is that we'll
-	 * try to pull out enough data from the source to get that word-
-	 * aligned, then do our writes word-aligned, storing the difference
-	 * in a register, and shifting the data as needed.
-	 */
-neon_memcpy_nonaligned:
-	/*
-	 * If this is <8 bytes, it makes more sense to just copy it
-	 * quickly instead of incurring all kinds of overhead.
-	 */
-	cmp		r2, #8 /* Let's try this...*/
-	ble		neon_copy_finish
-	/*
-	 * This is where we'll pull out either 1, 2, or 3 bytes of data
-	 * from the source as needed to align it, then store off those
-	 * bytes in r4.  When we read in the (now) aligned data from the
-	 * source, we'll shift the bytes and AND in the r4 data, then write
-	 * to the target aligned.
-	 *
-	 * The conditional ldr calls work slightly faster than the
-	 * previous method, confirmed by our pipeline modeler.
-	 */
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r6-r9}
-#else
-	push		{r6-r9}
-#endif
-	cmp		r12, #2
-	ldrb		r4, [r1], #1
-	ldrleb		r5, [r1], #1
-	ldrltb		r6, [r1], #1
-	rsb		r8, r12, #4
-	sub		r2, r2, r8
-	lsl		r8, r8, #3
-	orrle		r4, r4, r5, lsl #8
-	orrlt		r4, r4, r6, lsl #16
-	rsb		r9, r8, #32
-	
-	cmp		r2, #64
-	blt		neon_unaligned_route
-	ands		r12, r0, #0xf
-	beq		neon_unaligned_route
-	rsb		r12, r12, #16
-neon_16_start_u:
-	sub		r2, r2, r12
-	lsrs		r6, r12, #2
-neon_align_16_4_u:
-	ldr		r5, [r1], #4
-	subs		r6, r6, #1
-	orr		r4, r4, r5, lsl r8
-	str		r4, [r0], #4
-	mov		r4, r5, lsr r9
-	bne		neon_align_16_4_u
-neon_unaligned_route:
-	/* Decide which loop block to branch to.*/
-	cmp		r2, #256
-	bge		neon_copy_64_u
-	cmp		r2, #64
-	bge		neon_copy_32_u
-	b		neon_copy_finish_u
-	/* Copy data in 64-byte blocks.*/
-neon_copy_64_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4}
-	vstmdb		sp!, {q5-q8}
-#else
-	vpush		{q4}
-	vpush		{q5-q8}
-#endif
-	/* We'll need this for the q register shift later.*/
-	vdup.u32	q8, r8
-	/*
-	 * As above, we determine how many times we can go through the
-	 * 64-byte copy loop, then countdown.
-	 */
-	mov		r12, r2, lsr #6
-	and		r2, r2, #0x3f
-neon_copy_64_u_loop:
-	/* Load 64-bytes into q4-q7.*/
-	vld1.32		{q4, q5}, [r1]!
-	vld1.32		{q6, q7}, [r1]!
-	/*
-	 * Shift q0-q3 right so everything but the data we need due to the
-	 * alignment falls off the right-hand side.  The branching
-	 * is needed, since vshr requires the shift to be an immediate
-	 * value.
-	 */
-	lsls		r5, r8, #28
-	bcc		neon_copy_64_u_b8
-	bpl		neon_copy_64_u_b16
-	vshr.u64	q0, q4, #40
-	vshr.u64	q1, q5, #40
-	vshr.u64	q2, q6, #40
-	vshr.u64	q3, q7, #40
-	b		neon_copy_64_unify
-neon_copy_64_u_b8:
-	vshr.u64	q0, q4, #56
-	vshr.u64	q1, q5, #56
-	vshr.u64	q2, q6, #56
-	vshr.u64	q3, q7, #56
-	b		neon_copy_64_unify
-neon_copy_64_u_b16:
-	vshr.u64	q0, q4, #48
-	vshr.u64	q1, q5, #48
-	vshr.u64	q2, q6, #48
-	vshr.u64	q3, q7, #48
-neon_copy_64_unify:
-	/*
-	 * Shift q4-q7 left by r8 bits to take the alignment into
-	 * account.
-	 */
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q4, q8, q4
-	vshl.u64	q5, q8, q5
-	vshl.u64	q6, q8, q6
-	vshl.u64	q7, q8, q7
-#else
-	vshl.u64	q4, q4, q8
-	vshl.u64	q5, q5, q8
-	vshl.u64	q6, q6, q8
-	vshl.u64	q7, q7, q8
-#endif
-	/*
-	 * The data in s14 will be needed for the next loop iteration.  Move
-	 * that to r5.
-	 */
-	vmov		r5, s14
-	/* We'll vorr the shifted data with the data that needs to move back.*/
-	vorr		d9, d9, d0
-	/* Copy the data from the previous loop into s14.*/
-	vmov		s14, r4
-	vorr		d10, d10, d1
-	vorr		d11, d11, d2
-	vorr		d12, d12, d3
-	vorr		d13, d13, d4
-	vorr		d14, d14, d5
-	vorr		d15, d15, d6
-	vorr		d8, d8, d7
-	subs		r12, r12, #1
-	pld		[r1, #0]
-	pld		[r1, #128]
-	/* Save off the r5 data into r4 for the next iteration.*/
-	mov		r4, r5
-	vst1.32		{q4, q5}, [r0]!
-	vst1.32		{q6, q7}, [r0]!
-	pld		[r0, #0]
-	pld		[r0, #128]
-	bne		neon_copy_64_u_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q5-q8}
-	vldmia		sp!, {q4}
-#else
-	vpop		{q5-q8}
-	vpop		{q4}
-#endif
-	cmp		r2, #32
-	bge		neon_copy_32_u
-	b		neon_copy_finish_u
-neon_copy_32_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4}
-#else
-	vpush		{q4}
-#endif
-	vdup.u32	q4, r8
-	mov		r12, r2, lsr #5
-	and		r2, r2, #0x1f
-neon_copy_32_u_loop:
-	vld1.32		{q0, q1}, [r1]!
-	lsls		r5, r8, #28
-	bcc		neon_copy_32_u_b8
-	bpl		neon_copy_32_u_b16
-	vshr.u64	q2, q0, #40
-	vshr.u64	q3, q1, #40
-	b		neon_copy_32_unify
-neon_copy_32_u_b8:
-	vshr.u64	q2, q0, #56
-	vshr.u64	q3, q1, #56
-	b		neon_copy_32_unify
-neon_copy_32_u_b16:
-	vshr.u64	q2, q0, #48
-	vshr.u64	q3, q1, #48
-neon_copy_32_unify:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q0, q4, q0
-	vshl.u64	q1, q4, q1
-#else
-	vshl.u64	q0, q0, q4
-	vshl.u64	q1, q1, q4
-#endif
-	vmov		r5, s14
-	vorr		d1, d1, d4
-	vmov		s14, r4
-	vorr		d2, d2, d5
-	vorr		d3, d3, d6
-	vorr		d0, d0, d7
-	subs		r12, r12, #1
-	pld		[r1, #0]
-	mov		r4, r5
-	vst1.32		{q0, q1}, [r0]!
-	bne		neon_copy_32_u_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q4}
-#else
-	vpop		{q4}
-#endif
-neon_copy_finish_u:
-neon_copy_16_u:
-	movs		r12, r2, lsr #4
-	beq		neon_copy_8_u
-	vdup.u32	q2, r8
-	and		r2, r2, #0xf
-neon_copy_16_u_loop:
-	vld1.32		{q0}, [r1]!
-	lsls		r5, r8, #28
-	bcc		neon_copy_16_u_b8
-	bpl		neon_copy_16_u_b16
-	vshr.u64	q1, q0, #40
-	b		neon_copy_16_unify
-neon_copy_16_u_b8:
-	vshr.u64	q1, q0, #56
-	b		neon_copy_16_unify
-neon_copy_16_u_b16:
-	vshr.u64	q1, q0, #48
-neon_copy_16_unify:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q0, q2, q0
-#else
-	vshl.u64	q0, q0, q2
-#endif
-	vmov		r5, s6
-	vorr		d1, d1, d2
-	vmov		s6, r4
-	vorr		d0, d0, d3
-	subs		r12, r12, #1
-	mov		r4, r5
-	vst1.32		{q0}, [r0]!
-	bne		neon_copy_16_u_loop
-neon_copy_8_u:
-	cmp		r2, #8
-	blt		neon_copy_4_u
-	ldm		r1!, {r6-r7}
-	subs		r2, r2, #8
-	orr		r4, r4, r6, lsl r8
-	mov		r5, r6, lsr r9
-	orr		r5, r5, r7, lsl r8
-	stm		r0!, {r4-r5}
-	mov		r4, r7, lsr r9
-neon_copy_4_u:
-	cmp		r2, #4
-	blt		neon_copy_last_bits_u
-	ldr		r5, [r1], #4
-	subs		r2, r2, #4
-	orr		r4, r4, r5, lsl r8
-	str		r4, [r0], #4
-	mov		r4, r5, lsr r9
-neon_copy_last_bits_u:
-	/*
-	 * Remember, r8 contains the size of the data in r4 in bits,
-	 * so to get to bytes we'll need to shift 3 places
-	 */
-	lsr		r8, r8, #0x3
-	/* Write out the bytes stored in r4.*/
-neon_copy_last_bits_u_loop:
-	strb		r4, [r0], #1
-	subs		r8, r8, #1
-	lsrne		r4, r4, #8
-	bne		neon_copy_last_bits_u_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r6-r9}
-#else
-	pop		{r6-r9}
-#endif
-neon_copy_finish:
-	cmp		r2, #0
-	beq		neon_end
-	/*
-	 * This just copies the data from source to target one byte
-	 * at a time.  For some small values, this makes more sense.
-	 * Note that since this code copies data a byte at a time,
-	 * both the aligned and unaligned paths can use it.
-	 */
-neon_copy_finish_loop:
-	ldrb		r4, [r1], #1
-	subs		r2, r2, #1
-	strb		r4, [r0], #1
-	bne		neon_copy_finish_loop
-neon_end:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r4-r5}
-	ldmia		sp!, {r0}
-#else
-	pop		{r4-r5}
-	pop		{r0}
-#endif
-	bx		lr
-
-	.endfunc
-	.end
diff --git git/src/neon_memmove.S git/src/neon_memmove.S
deleted file mode 100644
index 1bfe597..0000000
--- git/src/neon_memmove.S
+++ /dev/null
@@ -1,939 +0,0 @@
-/***************************************************************************
- Copyright (c) 2009, Code Aurora Forum. All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-     * Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-     * Redistributions in binary form must reproduce the above copyright
-       notice, this list of conditions and the following disclaimer in the
-       documentation and/or other materials provided with the distribution.
-     * Neither the name of Code Aurora nor the names of its contributors may
-       be used to endorse or promote products derived from this software
-       without specific prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
-  ***************************************************************************/
-
-/***************************************************************************
- *  Neon memmove: Attempts to do a memmove with Neon registers if possible,
- *     Inputs:
- *        dest: The destination buffer
- *        src: The source buffer
- *        n: The size of the buffer to transfer
- *     Outputs:
- *
- ***************************************************************************/
-
-/*
- * General note:
- * The original code that was compiled for rvct used PUSH/POP and VPUSH/VPOP
- * However, it looks like the 2006 CodeSourcery Assembler has issues generating
- * the correct object code for VPOP, resulting in horrific stack crashes.
- * As a result, I've temporarily move PUSH->STMDB, POP->LDMIA, VPUSH->VSTMDB,
- * and VPOP->VLDMIA.  We can revert this back once we update our toolchain.
- *
- * Also, VSHL swaps the source register and the shift-amount register
- * around in 2006-q3.  I've coded this incorrectly so it turns out correct
- * in the object code, but we'll need to undo that later...
- */
-	.code 32
-	.align 4
-	.globl neon_memmove
-	.func
-
-neon_memmove:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r0}
-#else
-	push		{r0}
-#endif
-
-	/*
-	 * The requirements for memmove state that the function should
-	 * operate as if data were being copied from the source to a
-	 * buffer, then to the destination.  This is to allow a user
-	 * to copy data from a source and target that overlap.
-	 *
-	 * We can't just do byte copies front-to-back automatically, since
-	 * there's a good chance we may have an overlap (why else would someone
-	 * intentionally use memmove then?).
-	 *
-	 * We'll break this into two parts.  Front-to-back, or back-to-front
-	 * copies.
-	 */
-neon_memmove_cmf:
-	cmp		r0, r1
-	blt		neon_front_to_back_copy
-	bgt		neon_back_to_front_copy
-	b		neon_memmove_done
-
-	/* #############################################################
-	 * Front to Back copy
-	 */
-neon_front_to_back_copy:
-	/*
-	 * For small copies, just do a quick memcpy.  We can do this for
-	 * front-to-back copies, aligned or unaligned, since we're only
-	 * doing 1 byte at a time...
-	 */
-	cmp		r2, #4
-	bgt		neon_f2b_gt4
-	cmp		r2, #0
-neon_f2b_smallcopy_loop:
-	beq		neon_memmove_done
-	ldrb		r12, [r1], #1
-	subs		r2, r2, #1
-	strb		r12, [r0], #1
-	b		neon_f2b_smallcopy_loop
-neon_f2b_gt4:
-	/* Preload what we can...*/
-	pld		[r0,#0]
-	pld		[r1,#0]	
-	/* The window size is in r3. */
-	sub		r3, r1, r0
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r4-r6}
-#else
-	push		{r4-r6}
-#endif
-
-neon_f2b_check_align:
-	/* Check alignment. */
-	ands		r12, r0, #0x3
-	beq		neon_f2b_source_align_check
-	cmp		r12, #2
-	ldrb		r4, [r1], #1
-	ldrleb		r5, [r1], #1
-	ldrltb		r6, [r1], #1
-	rsb		r12, r12, #4
-	sub		r2, r2, r12
-	strb		r4, [r0], #1
-	strleb		r5, [r0], #1
-	strltb		r6, [r0], #1
-	
-neon_f2b_source_align_check:
-	ands		r12, r1, #0x3
-	bne		neon_f2b_nonaligned
-
-neon_f2b_try_16_align:
-	/* If we're >64, attempt to align on 16-bytes.  Smaller amounts
-	 * don't seem to be worth handling. */
-	cmp		r2, #64
-	blt		neon_f2b_align_route
-	/* This is where we try 16-byte alignment. */
-	ands		r12, r0, #0xf
-	beq		neon_f2b_align_route
-	rsb		r12, r12, #16
-neon_f2b_16_start:
-	sub		r2, r2, r12
-	lsrs		r5, r12, #2
-neon_f2b_align_16_4:
-	ldr		r4, [r1], #4
-	subs		r5, r5, #1
-	str		r4, [r0], #4
-	bne		neon_f2b_align_16_4
-neon_f2b_align_route:
-	/* #############################################################
-	 * Front to Back copy - aligned
-	 */
-	/*
-	 * Note that we can't just route based on the size in r2.  If that's
-	 * larger than the overlap window in r3, we could potentially
-	 * (and likely!) destroy data we're copying.
-	 */
-	cmp		r2, r3
-	movle		r12, r2
-	movgt		r12, r3
-	cmp		r12, #256
-	bge		neon_f2b_copy_128_a
-	cmp		r12, #64
-	bge		neon_f2b_copy_32_a
-	cmp		r12, #16
-	bge		neon_f2b_copy_16_a
-	cmp		r12, #8
-	bge		neon_f2b_copy_8_a
-	cmp		r12, #4
-	bge		neon_f2b_copy_4_a
-	b		neon_f2b_copy_1_a
-neon_f2b_copy_128_a:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4-q7}
-#else
-	vpush		{q4-q7}
-#endif
-	mov		r12, r2, lsr #7
-neon_f2b_copy_128_a_loop:
-	vld1.32		{q0,q1}, [r1]!
-	vld1.32		{q2,q3}, [r1]!
-	vld1.32		{q4,q5}, [r1]!
-	vld1.32		{q6,q7}, [r1]!
-	pld		[r1, #0]
-	pld		[r1, #128]
-	vst1.32		{q0,q1}, [r0]!
-	vst1.32		{q2,q3}, [r0]!
-	vst1.32		{q4,q5}, [r0]!
-	vst1.32		{q6,q7}, [r0]!
-	subs		r12, r12, #1
-	pld		[r0, #0]
-	pld		[r0, #128]
-	bne		neon_f2b_copy_128_a_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q4-q7}
-#else
-	vpop		{q4-q7}
-#endif
-	ands		r2, r2, #0x7f
-	beq		neon_f2b_finish
-	cmp		r2, #32
-	bge		neon_f2b_copy_32_a
-	b		neon_f2b_copy_finish_a
-neon_f2b_copy_32_a:
-	mov		r12, r2, lsr #5
-neon_f2b_copy_32_a_loop:
-	vld1.32		{q0,q1}, [r1]!
-	subs		r12, r12, #1
-	pld		[r1, #0]
-	vst1.32		{q0,q1}, [r0]!
-	bne		neon_f2b_copy_32_a_loop
-	ands		r2, r2, #0x1f
-	beq		neon_f2b_finish
-neon_f2b_copy_finish_a:
-neon_f2b_copy_16_a:
-	movs		r12, r2, lsr #4
-	beq		neon_f2b_copy_8_a
-neon_f2b_copy_16_a_loop:
-	vld1.32		{q0}, [r1]!
-	subs		r12, r12, #1
-	vst1.32		{q0}, [r0]!
-	bne		neon_f2b_copy_16_a_loop
-	ands		r2, r2, #0xf
-	beq		neon_f2b_finish
-neon_f2b_copy_8_a:
-	cmp		r2, #8
-	blt		neon_f2b_copy_4_a
-	ldm		r1!, {r4-r5}
-	subs		r2, r2, #8
-	stm		r0!, {r4-r5}
-neon_f2b_copy_4_a:
-	cmp		r2, #4
-	blt		neon_f2b_copy_1_a
-	ldr		r4, [r1], #4
-	subs		r2, r2, #4
-	str		r4, [r0], #4
-neon_f2b_copy_1_a:
-	cmp		r2, #0
-	beq		neon_f2b_finish
-neon_f2b_copy_1_a_loop:
-	ldrb		r12, [r1], #1
-	subs		r2, r2, #1
-	strb		r12, [r0], #1
-	bne		neon_f2b_copy_1_a_loop
-	b		neon_f2b_finish
-		
-	/* #############################################################
-	 * Front to Back copy - unaligned
-	 */
-neon_f2b_nonaligned:
-	/*
-	 * For sizes < 8, does it really make sense to do the whole shift
-	 * party?  Note that we DON'T want to call neon_f2b_copy_1_u,
-	 * since we'll end up trying to pop r8-r11, and we DON'T want
-	 * to do that...
-	 */
-	cmp		r2, #8
-	ble		neon_f2b_copy_1_a
-
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r7-r9}
-#else
-	push		{r7-r9}
-#endif
-	cmp		r12, #2
-	ldrb		r4, [r1], #1
-	ldrleb		r5, [r1], #1
-	ldrltb		r6, [r1], #1
-	rsb		r8, r12, #4
-	sub		r2, r2, r8
-	lsl		r8, r8, #3
-	orrle		r4, r4, r5, lsl #8
-	orrlt		r4, r4, r6, lsl #16
-	rsb		r9, r8, #32
-	/*
-	 * r4  = overflow bits
-	 * r8 = # of bits we copied into the r4 register to align source.
-	 * r9 = 32 - r8
-	 * r12 = Index counter for each size, so we determine how many times
-	 *       the given size will go into r2, then count down that # of
-	 *       times in r12.
-	 */
-	cmp		r2, #64
-	blt		neon_f2b_unaligned_route
-	ands		r12, r0, #0xf
-	beq		neon_f2b_unaligned_route
-	cmp		r3, #4
-	blt		neon_f2b_unaligned_route
-	rsb		r12, r12, #16
-neon_f2b_16_start_u:
-	sub		r2, r2, r12
-	lsrs		r6, r12, #2
-neon_f2b_align_16_4_u:
-	ldr		r5, [r1], #4
-	subs		r6, r6, #1
-	orr		r4, r4, r5, lsl r8
-	str		r4, [r0], #4
-	mov		r4, r5, lsr r9
-	bne		neon_f2b_align_16_4_u
-neon_f2b_unaligned_route:
-	cmp		r2, r3
-	movle		r12, r2
-	movgt		r12, r3
-	cmp		r12, #256
-	bge		neon_f2b_copy_64_u
-	cmp		r12, #64
-	bge		neon_f2b_copy_32_u
-	cmp		r12, #16
-	bge		neon_f2b_copy_16_u
-	cmp		r12, #8
-	bge		neon_f2b_copy_8_u
-	cmp		r12, #4
-	bge		neon_f2b_copy_4_u
-	b		neon_f2b_last_bits_u
-neon_f2b_copy_64_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4}
-	vstmdb		sp!, {q5-q8}
-#else
-	vpush		{q4}
-	vpush		{q5-q8}
-#endif
-	vdup.u32	q8, r8
-	mov		r12, r2, lsr #6
-	and		r2, r2, #0x3f
-neon_f2b_copy_64_u_loop:
-	vld1.32		{q4, q5}, [r1]!
-	vld1.32		{q6, q7}, [r1]!
-	lsls		r5, r8, #28
-	bcc		neon_f2b_copy_64_u_b8
-	bpl		neon_f2b_copy_64_u_b16
-	vshr.u64	q0, q4, #40
-	vshr.u64	q1, q5, #40
-	vshr.u64	q2, q6, #40
-	vshr.u64	q3, q7, #40
-	b		neon_f2b_copy_64_unify
-neon_f2b_copy_64_u_b8:
-	vshr.u64	q0, q4, #56
-	vshr.u64	q1, q5, #56
-	vshr.u64	q2, q6, #56
-	vshr.u64	q3, q7, #56
-	b		neon_f2b_copy_64_unify
-neon_f2b_copy_64_u_b16:
-	vshr.u64	q0, q4, #48
-	vshr.u64	q1, q5, #48
-	vshr.u64	q2, q6, #48
-	vshr.u64	q3, q7, #48
-neon_f2b_copy_64_unify:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q4, q8, q4
-	vshl.u64	q5, q8, q5
-	vshl.u64	q6, q8, q6
-	vshl.u64	q7, q8, q7
-#else
-	vshl.u64	q4, q4, q8
-	vshl.u64	q5, q5, q8
-	vshl.u64	q6, q6, q8
-	vshl.u64	q7, q7, q8
-#endif
-	vmov		r5, s14
-	vorr		d9, d9, d0
-	vmov		s14, r4
-	vorr		d10, d10, d1
-	vorr		d11, d11, d2
-	vorr		d12, d12, d3
-	vorr		d13, d13, d4
-	vorr		d14, d14, d5
-	vorr		d15, d15, d6
-	vorr		d8, d8, d7
-	subs		r12, r12, #1
-	pld		[r1, #0]
-	pld		[r1, #128]
-	mov		r4, r5
-	vst1.32		{q4, q5}, [r0]!
-	vst1.32		{q6, q7}, [r0]!
-	pld		[r0, #0]
-	pld		[r0, #128]
-	bne		neon_f2b_copy_64_u_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q5-q8}
-	vldmia		sp!, {q4}
-#else
-	vpop		{q5-q8}
-	vpop		{q4}
-#endif
-	cmp		r2, #32
-	bge		neon_f2b_copy_32_u
-	b		neon_f2b_copy_finish_u
-neon_f2b_copy_32_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4}
-#else
-	vpush		{q4}
-#endif
-	vdup.u32	q4, r8
-	mov		r12, r2, lsr #5
-	and		r2, r2, #0x1f
-neon_f2b_copy_32_u_loop:
-	vld1.32		{q0, q1}, [r1]!
-	lsls		r5, r8, #28
-	bcc		neon_f2b_copy_32_u_b8
-	bpl		neon_f2b_copy_32_u_b16
-	vshr.u64	q2, q0, #40
-	vshr.u64	q3, q1, #40
-	b		neon_f2b_copy_32_unify
-neon_f2b_copy_32_u_b8:
-	vshr.u64	q2, q0, #56
-	vshr.u64	q3, q1, #56
-	b		neon_f2b_copy_32_unify
-neon_f2b_copy_32_u_b16:
-	vshr.u64	q2, q0, #48
-	vshr.u64	q3, q1, #48
-neon_f2b_copy_32_unify:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q0, q4, q0
-	vshl.u64	q1, q4, q1
-#else
-	vshl.u64	q0, q0, q4
-	vshl.u64	q1, q1, q4
-#endif
-	vmov		r5, s14
-	vorr		d1, d1, d4
-	vmov		s14, r4
-	vorr		d2, d2, d5
-	vorr		d3, d3, d6
-	vorr		d0, d0, d7
-	subs		r12, r12, #1
-	pld		[r1, #0]
-	mov		r4, r5
-	vst1.32		{q0, q1}, [r0]!
-	bne		neon_f2b_copy_32_u_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q4}
-#else
-	vpop		{q4}
-#endif
-neon_f2b_copy_finish_u:
-neon_f2b_copy_16_u:
-	movs		r12, r2, lsr #4
-	beq		neon_f2b_copy_8_u
-	vdup.u32	q2, r8
-	and		r2, r2, #0xf
-neon_f2b_copy_16_u_loop:
-	vld1.32		{q0}, [r1]!
-	lsls		r5, r8, #28
-	bcc		neon_f2b_copy_16_u_b8
-	bpl		neon_f2b_copy_16_u_b16
-	vshr.u64	q1, q0, #40
-	b		neon_f2b_copy_16_unify
-neon_f2b_copy_16_u_b8:
-	vshr.u64	q1, q0, #56
-	b		neon_f2b_copy_16_unify
-neon_f2b_copy_16_u_b16:
-	vshr.u64	q1, q0, #48
-neon_f2b_copy_16_unify:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q0, q2, q0
-#else
-	vshl.u64	q0, q0, q2
-#endif
-	vmov		r5, s6
-	vorr		d1, d1, d2
-	vmov		s6, r4
-	vorr		d0, d0, d3
-	subs		r12, r12, #1
-	mov		r4, r5
-	vst1.32		{q0}, [r0]!
-	bne		neon_f2b_copy_16_u_loop
-neon_f2b_copy_8_u:
-	cmp		r2, #8
-	blt		neon_f2b_copy_4_u
-	ldm		r1!, {r6-r7}
-	subs		r2, r2, #8
-	orr		r4, r4, r6, lsl r8
-	mov		r5, r6, lsr r9
-	orr		r5, r5, r7, lsl r8
-	stm		r0!, {r4-r5}
-	mov		r4, r7, lsr r9
-neon_f2b_copy_4_u:
-	cmp		r2, #4
-	blt		neon_f2b_last_bits_u
-	ldr		r5, [r1], #4
-	subs		r2, r2, #4
-	orr		r4, r4, r5, lsl r8
-	str		r4, [r0], #4
-	mov		r4, r5, lsr r9
-neon_f2b_last_bits_u:
-	lsr		r8, r8, #0x3
-neon_f2b_last_bits_u_loop:
-	strb		r4, [r0], #1
-	subs		r8, r8, #1
-	lsr		r4, r4, #8
-	bne		neon_f2b_last_bits_u_loop
-neon_f2b_copy_1_u:
-	cmp		r2, #0
-	beq		neon_f2b_finish_u
-neon_f2b_copy_1_u_loop:
-	ldrb		r12, [r1], #1
-	subs		r2, r2, #1
-	strb		r12, [r0], #1
-	bne		neon_f2b_copy_1_u_loop
-neon_f2b_finish_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r7-r9}
-#else
-	pop		{r7-r9}
-#endif
-	/* #############################################################
-	 * Front to Back copy - finish
-	 */
-neon_f2b_finish:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r4-r6}
-#else
-	pop		{r4-r6}
-#endif
-	b		neon_memmove_done
-
-	/* #############################################################
-	 * Back to Front copy
-	 */
-neon_back_to_front_copy:
-	/*
-	 * Here, we'll want to shift to the end of the buffers.  This
-	 * actually points us one past where we need to go, but since
-	 * we'll pre-decrement throughout, this will be fine.
-	 */
-	add		r0, r0, r2
-	add		r1, r1, r2
-	cmp		r2, #4
-	bgt		neon_b2f_gt4
-	cmp		r2, #0
-neon_b2f_smallcopy_loop:
-	beq		neon_memmove_done
-	ldrb		r12, [r1, #-1]!
-	subs		r2, r2, #1
-	strb		r12, [r0, #-1]!
-	b		neon_b2f_smallcopy_loop
-neon_b2f_gt4:
-	pld		[r0, #0]
-	pld		[r1, #0]
-	/*
-	 * The minimum of the overlap window size and the copy size
-	 * is in r3.
-	 */
-	sub		r3, r0, r1
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r4-r5}
-#else
-	push		{r4-r5}
-#endif
-
-	/*
-	 * Check alignment.  Since we'll pre-decrement as we step thru, we'll
-	 * need to make sure we're on word-alignment.
-	 */
-neon_b2f_check_align:
-	ands		r12, r0, #0x3
-	beq		neon_b2f_source_align_check
-	sub		r2, r2, r12
-neon_b2f_shift_align:
-	ldrb		r4, [r1, #-1]!
-	subs		r12, r12, #1
-	strb		r4, [r0, #-1]!
-	bne		neon_b2f_shift_align
-neon_b2f_source_align_check:
-	ands		r4, r1, #0x3
-	bne		neon_b2f_nonaligned
-	
-neon_b2f_try_16_align:
-	/* If we're >64, attempt to align on 16-bytes.  Smaller amounts
-	 * don't seem to be worth handling. */
-	cmp		r2, #64
-	blt		neon_b2f_align_route
-	ands		r12, r0, #0xf
-	beq		neon_b2f_align_route
-	/* In this case, r12 has the number of bytes to roll backward. */
-neon_b2f_16_start:
-	sub		r2, r2, r12
-	lsrs		r5, r12, #2
-neon_b2f_align_16_4:
-	ldr		r4, [r1, #-4]!
-	subs		r5, r5, #1
-	str		r4, [r0, #-4]!
-	bne		neon_b2f_align_16_4
-neon_b2f_align_route:
-	/*
-	 * #############################################################
-	 * Back to Front copy - aligned
-	 */
-	cmp		r2, r3
-	movle		r12, r2
-	movgt		r12, r3
-	cmp		r12, #256
-	bge		neon_b2f_copy_128_a
-	cmp		r12, #64
-	bge		neon_b2f_copy_32_a
-	cmp		r12, #8
-	bge		neon_b2f_copy_8_a
-	cmp		r12, #4
-	bge		neon_b2f_copy_4_a
-	b		neon_b2f_copy_1_a
-neon_b2f_copy_128_a:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4-q7}
-#else
-	vpush		{q4-q7}
-#endif
-	movs		r12, r2, lsr #7
-	/*
-	 * This irks me.  There MUST be a better way to read these in and
-	 * scan the register backward instead of making it go forward.  Then
-	 * we need to do two subtractions...
-	 */
-neon_b2f_copy_128_a_loop:
-	sub		r1, r1, #128
-	sub		r0, r0, #128
-	vld1.32		{q0, q1}, [r1]!
-	vld1.32		{q2, q3}, [r1]!
-	vld1.32		{q4, q5}, [r1]!
-	vld1.32		{q6, q7}, [r1]!
-	pld		[r1, #-128]
-	pld		[r1, #-256]
-	vst1.32		{q0, q1}, [r0]!
-	vst1.32		{q2, q3}, [r0]!
-	vst1.32		{q4, q5}, [r0]!
-	vst1.32		{q6, q7}, [r0]!
-	subs		r12, r12, #1
-	pld		[r0, #-128]
-	pld		[r0, #-256]
-	sub		r1, r1, #128
-	sub		r0, r0, #128
-	bne		neon_b2f_copy_128_a_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q4-q7}
-#else
-	vpop		{q4-q7}
-#endif
-	ands		r2, r2, #0x7f
-	beq		neon_b2f_finish
-	cmp		r2, #32
-	bge		neon_b2f_copy_32_a
-	b		neon_b2f_copy_finish_a
-neon_b2f_copy_32_a:
-	mov		r12, r2, lsr #5
-neon_b2f_copy_32_a_loop:
-	sub		r1, r1, #32
-	sub		r0, r0, #32
-	vld1.32		{q0,q1}, [r1]
-	subs		r12, r12, #1
-	vst1.32		{q0,q1}, [r0]
-	pld		[r1, #0]
-	bne		neon_b2f_copy_32_a_loop
-	ands		r2, r2, #0x1f
-	beq		neon_b2f_finish
-neon_b2f_copy_finish_a:
-neon_b2f_copy_8_a:
-	movs		r12, r2, lsr #0x3
-	beq		neon_b2f_copy_4_a
-neon_b2f_copy_8_a_loop:
-	ldmdb		r1!, {r4-r5}
-	subs		r12, r12, #1
-	stmdb		r0!, {r4-r5}
-	bne		neon_b2f_copy_8_a_loop
-	and		r2, r2, #0x7
-neon_b2f_copy_4_a:
-	movs		r12, r2, lsr #0x2
-	beq		neon_b2f_copy_1_a
-	and		r2, r2, #0x3
-neon_b2f_copy_4_a_loop:
-	ldr		r4, [r1, #-4]!
-	subs		r12, r12, #1
-	str		r4, [r0, #-4]!
-	bne		neon_b2f_copy_4_a_loop
-neon_b2f_copy_1_a:
-	cmp		r2, #0
-	beq		neon_b2f_finish
-neon_b2f_copy_1_a_loop:
-	ldrb		r12, [r1, #-1]!
-	subs		r2, r2, #1
-	strb		r12, [r0, #-1]!
-	bne		neon_b2f_copy_1_a_loop
-
-	/* #############################################################
-	 * Back to Front copy - unaligned
-	 */
-neon_b2f_nonaligned:
-	/*
-	 * For sizes < 8, does it really make sense to do the whole shift
-	 * party?
-	 */
-	cmp		r2, #8
-	ble		neon_b2f_copy_1_a
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	stmdb		sp!, {r6-r11}
-#else
-	push		{r6-r11}
-#endif
-	/*
-	 * r3 = max window size
-	 * r4 = overflow bytes
-	 * r5 = bytes we're reading into
-	 * r6 = # bytes we're off.
-	 * r10 = copy of r6
-	 */
-	and		r6, r1, #0x3
-	eor		r4, r4, r4
-	mov		r10, r6
-neon_b2f_realign:
-	ldrb		r5, [r1, #-1]!
-	subs		r6, r6, #1
-	orr		r4, r5, r4, lsl #8
-	bne		neon_b2f_realign
-	/*
-	 * r10 = # of bits we copied into the r4 register to align source.
-	 * r11 = 32 - r10
-	 * r12 = Index counter for each size, so we determine how many times
-	 *       the given size will go into r2, then count down that # of
-	 *       times in r12.
-	 */
-	sub		r2, r2, r10
-	lsl		r10, r10, #0x3
-	rsb		r11, r10, #32
-
-	cmp		r2, r3
-	movle		r12, r2
-	movgt		r12, r3
-	cmp		r12, #256
-	bge		neon_b2f_copy_64_u
-	cmp		r12, #64
-	bge		neon_b2f_copy_32_u
-	cmp		r12, #8
-	bge		neon_b2f_copy_8_u
-	cmp		r12, #4
-	bge		neon_b2f_copy_4_u
-	b		neon_b2f_last_bits_u
-neon_b2f_copy_64_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4,q5}
-	vstmdb		sp!, {q6-q8}
-#else
-	vpush		{q4,q5}
-	vpush		{q6-q8}
-#endif
-	add		r7, r11, #32
-	movs		r12, r2, lsr #6
-	vdup.u32	q8, r7
-neon_b2f_copy_64_u_loop:
-	sub		r1, r1, #64
-	sub		r0, r0, #64
-	vld1.32		{q0, q1}, [r1]!
-	vld1.32		{q2, q3}, [r1]
-	sub		r1, r1, #32
-	vmov		q4, q0
-	vmov		q5, q1
-	vmov		q6, q2
-	vmov		q7, q3
-	vmov		r5, s0
-	mov		r4, r4, lsl r11
-	lsls		r6, r10, #28
-	bcc		neon_b2f_copy_64_u_b8
-	bpl		neon_b2f_copy_64_u_b16
-	vshr.u64	q0, q0, #24
-	vshr.u64	q1, q1, #24
-	vshr.u64	q2, q2, #24
-	vshr.u64	q3, q3, #24
-	b		neon_b2f_copy_64_unify
-neon_b2f_copy_64_u_b8:
-	vshr.u64	q0, q0, #8
-	vshr.u64	q1, q1, #8
-	vshr.u64	q2, q2, #8
-	vshr.u64	q3, q3, #8
-	b		neon_b2f_copy_64_unify
-neon_b2f_copy_64_u_b16:
-	vshr.u64	q0, q0, #16
-	vshr.u64	q1, q1, #16
-	vshr.u64	q2, q2, #16
-	vshr.u64	q3, q3, #16
-neon_b2f_copy_64_unify:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q4, q8, q4
-	vshl.u64	q5, q8, q5
-	vshl.u64	q6, q8, q6
-	vshl.u64	q7, q8, q7
-#else
-	vshl.u64	q4, q4, q8
-	vshl.u64	q5, q5, q8
-	vshl.u64	q6, q6, q8
-	vshl.u64	q7, q7, q8
-#endif
-	vmov		s17, r4
-	vorr		d7, d7, d8
-	vorr		d6, d6, d15
-	vorr		d5, d5, d14
-	vorr		d4, d4, d13
-	vorr		d3, d3, d12
-	vorr		d2, d2, d11
-	vorr		d1, d1, d10
-	vorr		d0, d0, d9
-	mov		r4, r5, lsl r11
-	subs		r12, r12, #1
-	lsr		r4, r4, r11
-	vst1.32		{q0, q1}, [r0]!
-	vst1.32		{q2, q3}, [r0]
-	pld		[r1, #0]
-	sub		r0, r0, #32
-	bne		neon_b2f_copy_64_u_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q6-q8}
-	vldmia		sp!, {q4,q5}
-#else
-	vpop		{q6-q8}
-	vpop		{q4,q5}
-#endif
-	ands		r2, r2, #0x3f
-	cmp		r2, #32
-	bge		neon_b2f_copy_32_u
-	b		neon_b2f_copy_finish_u
-neon_b2f_copy_32_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vstmdb		sp!, {q4}
-#else
-	vpush		{q4}
-#endif
-	add		r7, r11, #32
-	movs		r12, r2, lsr #5
-	vdup.u32	q4, r7
-	and		r2, r2, #0x1f
-neon_b2f_copy_32_u_loop:
-	sub		r1, r1, #32
-	sub		r0, r0, #32
-	vld1.32		{q0, q1}, [r1]
-	vmov		q2, q0
-	vmov		q3, q1
-	vmov		r5, s0
-	mov		r4, r4, lsl r11
-	lsls		r6, r10, #28
-	bcc		neon_b2f_copy_32_u_b8
-	bpl		neon_b2f_copy_32_u_b16
-	vshr.u64	q0, q0, #24
-	vshr.u64	q1, q1, #24
-	b		neon_b2f_copy_32_unify
-neon_b2f_copy_32_u_b8:
-	vshr.u64	q0, q0, #8
-	vshr.u64	q1, q1, #8
-	b		neon_b2f_copy_32_unify
-neon_b2f_copy_32_u_b16:
-	vshr.u64	q0, q0, #16
-	vshr.u64	q1, q1, #16
-neon_b2f_copy_32_unify:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vshl.u64	q2, q4, q2
-	vshl.u64	q3, q4, q3
-#else
-	vshl.u64	q2, q2, q4
-	vshl.u64	q3, q3, q4
-#endif
-	vmov		s9, r4
-	vorr		d3, d3, d4
-	vorr		d2, d2, d7
-	vorr		d1, d1, d6
-	vorr		d0, d0, d5
-	mov		r4, r5, lsl r11
-	subs		r12, r12, #1
-	lsr		r4, r4, r11
-	vst1.32		{q0, q1}, [r0]
-	pld		[r1, #0]
-	bne		neon_b2f_copy_32_u_loop
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	vldmia		sp!, {q4}
-#else
-	vpop		{q4}
-#endif
-neon_b2f_copy_finish_u:
-neon_b2f_copy_8_u:
-	movs		r12, r2, lsr #0x3
-	beq		neon_b2f_copy_4_u
-	mov		r5, r4, lsl r11
-neon_b2f_copy_8_u_loop:
-	ldmdb		r1!, {r6-r7}
-	subs		r12, r12, #1
-	orr		r5, r5, r7, lsr r10
-	mov		r4, r7, lsl r11
-	orr		r4, r4, r6, lsr r10
-	stmdb		r0!, {r4-r5}
-	mov		r4, r6, lsl r11
-	lsr		r4, r4, r11
-	mov		r5, r4, lsl r11
-	bne		neon_b2f_copy_8_u_loop
-	ands		r2, r2, #0x7
-neon_b2f_copy_4_u:
-	movs		r12, r2, lsr #0x2
-	beq		neon_b2f_last_bits_u
-	mov		r5, r4, lsl r11
-neon_b2f_copy_4_u_loop:
-	ldr		r6, [r1, #-4]!
-	subs		r12, r12, #1
-	orr		r5, r5, r6, lsr r10
-	str		r5, [r0, #-4]!
-	mov		r4, r6, lsl r11
-	lsr		r4, r4, r11
-	mov		r5, r4, lsl r11
-	bne		neon_b2f_copy_4_u_loop
-	and		r2, r2, #0x3
-neon_b2f_last_bits_u:
-neon_b2f_last_bits_u_loop:
-	subs		r10, r10, #8
-	mov		r5, r4, lsr r10
-	strb		r5, [r0, #-1]!
-	bne		neon_b2f_last_bits_u_loop
-neon_b2f_copy_1_u:
-	cmp		r2, #0
-	beq		neon_b2f_finish_u
-neon_b2f_copy_1_u_loop:
-	ldrb		r12, [r1, #-1]!
-	subs		r2, r2, #1
-	strb		r12, [r0, #-1]!
-	bne		neon_b2f_copy_1_u_loop
-neon_b2f_finish_u:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r6-r11}
-#else
-	pop		{r6-r11}
-#endif
-
-neon_b2f_finish:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r4-r5}
-#else
-	pop		{r4-r5}
-#endif
-
-neon_memmove_done:
-#if defined __GNUC__ && (4 == __GNUC__ && 1 == __GNUC_MINOR__ && 1 == __GNUC_PATCHLEVEL__)
-	ldmia		sp!, {r0}
-#else
-	pop		{r0}
-#endif
-	bx		lr
-
-	.endfunc
-	.end
diff --git git/src/neon_memsets.c git/src/neon_memsets.c
deleted file mode 100755
index 740fc1e..0000000
--- git/src/neon_memsets.c
+++ /dev/null
@@ -1,169 +0,0 @@
-/* neon_memsets.c
- *
- * Copyright (c) 2009, Code Aurora Forum. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of Code Aurora nor
- *       the names of its contributors may be used to endorse or promote
- *       products derived from this software without specific prior written
- *       permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
- * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
- * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
- * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "msm-swblits.h"
-
-void memset16(uint16_t dst[], uint16_t value, int count)
-{
-    if (count <= 0)
-        return;
-
-    asm volatile(
-                 "       pld        [%[dst], #0]                           \n"
-                 "       cmp        %[count], #4                           \n"
-                 "       blt        6f                                     \n"
-                 "       tst        %[dst], #0x3                           \n"
-                 "       strneh     %[value], [%[dst]], #2                 \n"
-                 "       subne      %[count], %[count], #1                 \n"
-                 "       vdup.u16   q8, %[value]                           \n"
-                 "       vmov       q9, q8                                 \n"
-                 "       cmp        %[count], #64                          \n"
-                 "       bge        0f                                     \n"
-                 "       cmp        %[count], #32                          \n"
-                 "       bge        2f                                     \n"
-                 "       cmp        %[count], #16                          \n"
-                 "       bge        3f                                     \n"
-                 "       cmp        %[count], #8                           \n"
-                 "       bge        4f                                     \n"
-                 "       b          5f                                     \n"
-                 "0:                                                       \n"
-                 "       mov        r12, %[count], lsr #6                  \n"
-                 "1:                                                       \n"
-                 "       vst1.16    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.16    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.16    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.16    {q8, q9}, [%[dst]]!                    \n"
-                 "       subs       r12, r12, #1                           \n"
-                 "       bne        1b                                     \n"
-                 "       ands       %[count], %[count], #0x3f              \n"
-                 "       beq        7f                                     \n"
-                 "2:                                                       \n"
-                 "       cmp        %[count], #32                          \n"
-                 "       blt        3f                                     \n"
-                 "       vst1.16    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.16    {q8, q9}, [%[dst]]!                    \n"
-                 "       subs       %[count], %[count], #32                \n"
-                 "       beq        7f                                     \n"
-                 "3:                                                       \n"
-                 "       cmp        %[count], #16                          \n"
-                 "       blt        4f                                     \n"
-                 "       vst1.16    {q8, q9}, [%[dst]]!                    \n"
-                 "       subs       %[count], %[count], #16                \n"
-                 "       beq        7f                                     \n"
-                 "4:                                                       \n"
-                 "       cmp        %[count], #8                           \n"
-                 "       blt        5f                                     \n"
-                 "       vst1.16    {q8}, [%[dst]]!                        \n"
-                 "       subs       %[count], %[count], #8                 \n"
-                 "       beq        7f                                     \n"
-                 "5:                                                       \n"
-                 "       cmp        %[count], #4                           \n"
-                 "       blt        6f                                     \n"
-                 "       vst1.16    {d16}, [%[dst]]!                       \n"
-                 "       subs       %[count], %[count], #4                 \n"
-                 "       beq        7f                                     \n"
-                 "6:                                                       \n"
-                 "       cmp        %[count], #0                           \n"
-                 "       blt        7f                                     \n"
-                 "       lsls       %[count], #31                          \n"
-                 "       strmih     %[value], [%[dst]], #2                 \n"
-                 "       strcsh     %[value], [%[dst]], #2                 \n"
-                 "       strcsh     %[value], [%[dst]], #2                 \n"
-                 "7:                                                       \n"
-                 // Clobbered input registers
-                 : [dst] "+r" (dst), [count] "+r" (count)
-                 // Unclobbered input
-                 : [value] "r" (value)
-                 // Clobbered registers
-                 : "q8", "q9", "r12", "cc", "memory"
-                 );
-}
-
-void memset32(uint32_t dst[], uint32_t value, int count)
-{
-    asm volatile(
-                 "       pld        [%[dst], #0]                           \n"
-                 "       cmp        %[count], #4                           \n"
-                 "       blt        5f                                     \n"
-                 "       vdup.u32   q8, %[value]                           \n"
-                 "       vmov       q9, q8                                 \n"
-                 "       cmp        %[count], #32                          \n"
-                 "       bge        0f                                     \n"
-                 "       cmp        %[count], #16                          \n"
-                 "       bge        2f                                     \n"
-                 "       cmp        %[count], #8                           \n"
-                 "       bge        3f                                     \n"
-                 "       b          4f                                     \n"
-                 "0:                                                       \n"
-                 "       mov        r12, %[count], lsr #5                  \n"
-                 "1:                                                       \n"
-                 "       vst1.32    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.32    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.32    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.32    {q8, q9}, [%[dst]]!                    \n"
-                 "       pld        [%[dst], #0]                           \n"
-                 "       subs       r12, r12, #1                           \n"
-                 "       bne        1b                                     \n"
-                 "       ands       %[count], %[count], #0x1f              \n"
-                 "       beq        6f                                     \n"
-                 "2:                                                       \n"
-                 "       cmp        %[count], #16                          \n"
-                 "       blt        3f                                     \n"
-                 "       vst1.32    {q8, q9}, [%[dst]]!                    \n"
-                 "       vst1.32    {q8, q9}, [%[dst]]!                    \n"
-                 "       subs       %[count], %[count], #16                \n"
-                 "       beq        6f                                     \n"
-                 "3:                                                       \n"
-                 "       cmp        %[count], #8                           \n"
-                 "       blt        4f                                     \n"
-                 "       vst1.32    {q8, q9}, [%[dst]]!                    \n"
-                 "       subs       %[count], %[count], #8                 \n"
-                 "       beq        6f                                     \n"
-                 "4:                                                       \n"
-                 "       cmp        %[count], #4                           \n"
-                 "       blt        5f                                     \n"
-                 "       vst1.32    {q8}, [%[dst]]!                        \n"
-                 "       subs       %[count], %[count], #4                 \n"
-                 "       beq        6f                                     \n"
-                 "5:                                                       \n"
-                 "       cmp        %[count], #0                           \n"
-                 "       beq        6f                                     \n"
-                 "       lsls       %[count], #31                          \n"
-                 "       strmi      %[value], [%[dst]], #4                 \n"
-                 "       strcs      %[value], [%[dst]], #4                 \n"
-                 "       strcs      %[value], [%[dst]], #4                 \n"
-                 "6: @end                                                  \n"
-                 // Clobbered input registers
-                 : [dst] "+r" (dst), [count] "+r" (count)
-                 // Unclobbered input
-                 : [value] "r" (value)
-                 // Clobbered registers
-                 : "q8", "q9", "r12", "cc", "memory"
-                 );
-}