#pragma once

#ifndef OPTIMIZE_FOR_LP64_INCLUDED

#define OPTIMIZE_FOR_LP64_INCLUDED

/* ========================================================================= */

/*

  *****************************************************************************

  *  OSSERVAZIONI                                                             *

  *****************************************************************************

  ____________OSS 1:___________________________________________________________

  se devo fare DUE MOLTIPLICAZIONI 13 bit * 8 bit posso farle in un

  colpo solo, ad esempio:

  siano X = xxxxxxxxxxxxx

  S = ssssssss

  Y = yyyyyyyyyyyyy

  T = tttttttt

  e devo calcolare

  U = X * S

  V = Y * T

  posso farlo in un colpo solo impacchettando i bit cosi':

  A = X       0 00000000 Y       = xxxxxxxxxxxxx 0 00000000 yyyyyyyyyyyyy

  B = 00000 S 0 00000000 00000 T = 00000ssssssss 0 00000000 00000tttttttt

  ora se faccio C = A * B si ha

  C = U ?????????????????????? V =

  = uuuuuuuuuuuuuuuuuuuuu ?????????????????????? vvvvvvvvvvvvvvvvvvvvv

  dove C e' di 64 bit; cioe' i primi 21 bit sono X * S = U

  e gli ultimi 21 sono Y * T = V

  ____________OSS 2:___________________________________________________________

  se devo fare DUE MOLTIPLICAZIONI 16 bit * 16 bit del tipo

  X * S = U

  Y * S = V

  con

  #X = 16,

  #Y = 16,

  #S = 16

  (dove l'operatore '#' da' come risultato il numero di bit di cui e' composto

  un numero intero)

  posso farle tutte e due in un solo colpo impacchettando i bit cosi':

  O = 0000000000000000,   #O = 16

  A = X O Y           ,   #A = 48

  B = S               ,   #B = 16

  C = A * B           ,   #C = 64

  dove i primi 32 bit sono X * S e i secondi 32 bit sono Y * S

  ____________OSS 3:___________________________________________________________

  se devo fare QUATTRO MOLTIPLICAZIONI 8 bit * 8 bit del tipo

  X * S = I           #X = 8, #S = 8, #I = 16

  Y * S = J           #Y = 8, #S = 8, #J = 16

  Z * S = K           #Z = 8, #S = 8, #K = 16

  W * S = L           #W = 8, #S = 8, #L = 16

  posso farle tutte e due in un solo colpo impacchettando i bit cosi':

  O = 00000000             #O = 8

  C = XOYOZOW * OOOOOOS    #C = 64

  dove

  I sono i primi 16 bit,

  J sono i secondi 16 bit,

  K sono i terzi 16 bit,

  L i quarti 16 bit

  _____________________________________________________________________________

  *****************************************************************************

  */

/* ========================================================================= */

#define OPTIMIZE_FOR_LP64

/* ========================================================================= */

#define MASK_FIRST_OF_3_X_16BIT 0x7FFFC00000000

#define MASK_SECOND_OF_3_X_16BIT 0x3FFFE0000

#define MASK_THIRD_OF_3_X_16BIT 0x1FFFF

#define FIRST_OF_3_X_16BIT(x) (x) >> 34

#define SECOND_OF_3_X_16BIT(x) ((x)&MASK_SECOND_OF_3_X_16BIT) >> 17;

#define THIRD_OF_3_X_16BIT(x) (x) & MASK_THIRD_OF_3_X_16BIT;

/* ========================================================================= */

#define MASK_FIRST_OF_2_X_24BIT 0x3FFFFFE000000

#define MASK_SECOND_OF_2_X_24BIT 0x1FFFFFF

#define FIRST_OF_2_X_24BIT(x) (x) >> 25

#define SECOND_OF_2_X_24BIT(x) (x) & MASK_SECOND_OF_2_X_24BIT

/* ========================================================================= */

#define MASK_FIRST_OF_2_X_32BIT 0xFFFFFFFF00000000

#define MASK_SECOND_OF_2_X_32BIT 0xFFFFFFFF

#define FIRST_OF_2_X_32BIT(x) (x) >> 32

#define SECOND_OF_2_X_32BIT(x) (x) & MASK_SECOND_OF_2_X_32BIT

/* ========================================================================= */

typedef unsigned char UINT8;

typedef unsigned short UINT16;

typedef unsigned int UINT24;

typedef unsigned int UINT32;

typedef unsigned long UINT50;

typedef unsigned long UINT51;

typedef unsigned long UINT64;

/* ========================================================================= */

#if 0

/* esegue a1+b1, a2+c2, a3+c3 in un'unica operazione */

UINT64  add_3_x_16bit ( UINT16 a1, UINT16 a2, UINT16 a3,

			UINT16 b1, UINT16 b2, UINT16 b3 );

/* esegue a1+b1, a2+b2 in un'unica operazione */

UINT50 add_2_x_24bit ( UINT24 a1, UINT24 a2,

		       UINT24 b1, UINT24 b2 );

/* esegue a1*b, a2*b in un'unica operazione */

UINT64 mult_2_x_16bit ( UINT16 a1, UINT16 a2,

			UINT16 b );

#endif

/* ========================================================================= */

/* ------------------------------------------------------------------------- */

#define ADD_3_X_16BIT(a1, a2, a3, b1, b2, b3)                                  \

  (0L | (UINT64)(a1) << 34 | (UINT64)(a2) << 17 | (a3)) +                      \

      (0L | (UINT64)(b1) << 34 | (UINT64)(b2) << 17 | (b3))

inline UINT64 add_3_x_16bit(UINT16 a1, UINT16 a2, UINT16 a3, UINT16 b1,

                            UINT16 b2, UINT16 b3) {

  return (0L | (UINT64)a1 << 34 | (UINT64)a2 << 17 | a3) +

         (0L | (UINT64)b1 << 34 | (UINT64)b2 << 17 | b3);

}

/* ------------------------------------------------------------------------- */

#define ADD_2_X_24BIT(a1, a2, b1, b2)                                          \

  (0L | (UINT64)(a1) << 25 | (a2)) + (0L | (UINT64)(b1) << 25 | (b2))

inline UINT50 add_2_x_24bit(UINT24 a1, UINT24 a2, UINT24 b1, UINT24 b2) {

  return (0L | (UINT64)a1 << 25 | a2) + (0L | (UINT64)b1 << 25 | b2);

}

/* ------------------------------------------------------------------------- */

#define MULT_2_X_16BIT(a1, a2, b)                                              \

  ((UINT64)b) * (((UINT64)(a1) << 32) | (UINT64)a2)

inline UINT64 mult_2_x_16bit(UINT16 a1, UINT16 a2, UINT16 b) {

  return (0L | (UINT64)a1 << 32 | a2) * b;

}

#endif