Sumowanie flag bitowych

Witam
Mam zdefiniowane flagi bitowe, które odpowiadają kolejno kolorom świateł oraz nadane im wartości:

#define G 0x0001 //GREEN = 1 = 00000001
#define R 0x0002 //RED = 2 = 00000010
#define A 0x0004 //AMBER = 4 = 00001000
#define X 0x0008 //GRAY = 8 = 10000000

Flagi reprezentują 6 światełek z których każda może przyjąć 4 wartości

Mam problemem jest usprawnieniem flag bitowych w taki sposób, aby po wybraniu którejkolwiek z 4096 kombinacji, np(G,A,A,R,R,G) otrzymać unikalną wartość, czyli aby suma flag np G+A+A+R+R+G była zawsze unikalna i którą można później zastosować np. w poniższym zapisie:

	
switch( SetState(X,X,X,X,X,X) )
{
  case G+G+G+G+G+G:
       //do something
  break;
  case G+A+A+R+R+G:
      //do something
  break;
}

Nie wiem na ile zastosowanie w tym przypadku flag bitowych się przyda. Jak na razie nie mam lepszego pomysłu.
Poniżej moja niedopracowana funkcja

DWORD SetState(DWORD REC, DWORD VS1, DWORD VS2, DWORD VD1, DWORD VD2, DWORD NAS )
{
  DWORD    m_state = 0;
  DWORD    m_REC   = 0;
  DWORD    m_VS1   = 0;
  DWORD    m_VS2   = 0;
  DWORD    m_VD1   = 0;
  DWORD    m_VD2   = 0;
  DWORD    m_NAS   = 0;
   
  m_REC |= (REC)<<1; 
  m_VS1 |= (VS1)<<2;
  m_VS2 |= (VS2)<<4;
  m_VD1 |= (VD1)<<8;
  m_VD2 |= (VD2)<<16;
  m_NAS |= (NAS)<<32;
  
  return  m_REC+m_VS1+m_VS2+m_VD1+m_VD2+m_NAS;;
}

Będę wdzięczny za jakieś sugestie, pomysły etc.

#define G 0
#define R 1
#define A 2
#define X 3

DWORD lights(DWORD f1,DWORD f2,DWORD f3,DWORD f4,DWORD f5,DWORD f6)
{
  return f1|(f2<<2)|(f3<<4)|(f4<<6)|(f5<<8)|(f6<<10);
}

Dziękuje za odpowiedź ale tak też próbowałem. Niestety liczby będą się w takim przypadku powtarzać i to bardzo często. Przespałem się z tym problemem i mam rozwiązanie, wystarczyło przesunąć bity o odpowiednią ilość pól tak aby wykluczyć dwukrotne ustawienie tego samego bitu. Korzystając z uproszczonego zapisu Azariena funkcja będzie wyglądać następująco:

#define G 1
#define R 2
#define A 3
#define X 4

DWORD SetState(DWORD f1,DWORD f2,DWORD f3,DWORD f4,DWORD f5,DWORD f6)
{
  return f1|(f2<<3)|(f3<<7)|(f4<<11)|(f5<<17)|(f6<<20);
}

Pozdrawiam, dzięki Azarien.