#include <stdio.h>

    static __inline__ int MIN(int a, int b){
    int result =a;
    __asm__ ("pminsw %1, %0" : "+x" (result) : "x" (b));
    return result;
    }
    static __inline__ int MAX(int a, int b){
    int result = a;
    __asm__ ("pmaxsw %1, %0" : "+x" (result) : "x" (b));
    return result;
    }
    static __inline__ unsigned long long rdtsc(void){
      unsigned long long int x;
    __asm__ volatile (".byte 0x0f, 0x31" :
      "=A" (x));
      return x;
    }

    #define MIN3(a, b, c) (MIN(MIN(a,b),c))
    #define MIN4(a, b, c, d) (MIN(MIN(a,b),MIN(c,d)))

    static __inline__ void sort6(int * in) {
      const int A=in[0], B=in[1], C=in[2], D=in[3], E=in[4], F=in[5];

      in[0] = MIN( MIN4(A,B,C,D),MIN(E,F) );

      const int
      AB = MAX(A, B),
      AC = MAX(A, C),
      AD = MAX(A, D),
      AE = MAX(A, E),
      AF = MAX(A, F),
      BC = MAX(B, C),
      BD = MAX(B, D),
      BE = MAX(B, E),
      BF = MAX(B, F),
      CD = MAX(C, D),
      CE = MAX(C, E),
      CF = MAX(C, F),
      DE = MAX(D, E),
      DF = MAX(D, F),
      EF = MAX(E, F);

      in[1] = MIN4 (
      MIN4( AB, AC, AD, AE ),
      MIN4( AF, BC, BD, BE ),
      MIN4( BF, CD, CE, CF ),
      MIN3( DE, DF, EF)
      );

      const int
      ABCD = MAX(AB,CD),
      ABCE = MAX(AB,CE),
      ABCF = MAX(AB,CF),
      ABDE = MAX(AB,DE),
      ABDF = MAX(AB,DF),
      ABEF = MAX(AB,EF),
      ACDE = MAX(AC,DE),
      ACDF = MAX(AC,DF),
      ACEF = MAX(AC,EF),
      ADEF = MAX(AD,EF),
      BCDE = MAX(BC,DE),
      BCDF = MAX(BC,DF),
      BCEF = MAX(BC,EF),
      BDEF = MAX(BD,EF),
      CDEF = MAX(CD,EF);

      in[3] = MIN4 (
      MIN4( ABCD, ABCE, ABCF, ABDE ),
      MIN4( ABDF, ABEF, ACDE, ACDF ),
      MIN4( ACEF, ADEF, BCDE, BCDF ),
      MIN3( BCEF, BDEF, CDEF )
      );

      const int
      ABCDE= MAX(ABCD,E),
      ABCDF= MAX(ABCD,F),
      ABCEF= MAX(ABCE,F),
      ABDEF= MAX(ABDE,F),
      ACDEF= MAX(ACDE,F),
      BCDEF= MAX(BCDE,F);

      in[4]= MIN (
      MIN4( ABCDE, ABCDF, ABCEF, ABDEF ),
      MIN ( ACDEF, BCDEF )
      );

      in[5] = MAX(ABCDE,F);

      in[2] = A+B+C+D+E+F-(in[0]+in[1]+in[3]+in[4]+in[5]);
    }

    int main(int argc, char ** argv) {
      int d[6][6] = {
        {1, 2, 3, 4, 5, 6},
        {6, 5, 4, 3, 2, 1},
        {100, 2, 300, 4, 500, 6},
        {100, 2, 3, 4, 500, 6},
        {1, 200, 3, 4, 5, 600},
        {1, 1, 2, 1, 2, 1}
      };

      unsigned long long cycles = rdtsc();
      for (int i = 0; i < 6; i++) {
        sort6(d[i]);
      }
      cycles = rdtsc() - cycles;
      printf("Time is %d\n", (unsigned)cycles);

      for (int i = 0; i < 6; i++) {
        printf("d%d : %d %d %d %d %d %d\n", i,
         d[i][0], d[i][1], d[i][2],
         d[i][3], d[i][4], d[i][5]);
      }
    }