// First make a lookup table of all the 24 possible hand ordering permutations:
int PERMS[24][4]={{0, 1, 2, 3}, {0, 1, 3, 2}, {0, 2, 1, 3}, {0, 2, 3, 1}, {0, 3, 1, 2}, {0, 3, 2, 1}, {1, 0, 2, 3}, {1, 0, 3, 2}, {1, 2, 0, 3}, {1, 2, 3, 0}, {1, 3, 0, 2}, {1, 3, 2, 0}, {2, 0, 1, 3}, {2, 0, 3, 1}, {2, 1, 0, 3}, {2, 1, 3, 0}, {2, 3, 0, 1}, {2, 3, 1, 0}, {3, 0, 1, 2}, {3, 0, 2, 1}, {3, 1, 0, 2}, {3, 1, 2, 0}, {3, 2, 0, 1}, {3, 2, 1, 0}};

// Next we need a function to map an unordered 4-card hand to a unique integer.
// NOTE: 140608=52^3, 2704=52^2, etc.
int getIndex(int c0, int c1, int c2, int c3) {
  return  c0*140608 + c1*2704 + c2*52 + c3;
}

// Next create a lookup table of size 52^4, which we will populate so as to map from unordered --> ordered index.
int lookup[7311616];

// You can now populate this as you create your ordering:
int handIndex=0;
for (int c0 = 0; c0 < 49; c0++) {	
  for (int c1 = c0+1; c1 < 50; c1++) {
    for (int c2 = c1+1; c2 < 51; c2++) {
      for (int c3 = c2+1; c3 < 52; c3++) {
        int hand[4]={c0, c1, c2, c3};
        for (int i=0; i<24; i++) {
          lookup[getIndex(hand[PERMS[i][0]],hand[PERMS[i][1]],hand[PERMS[i][2]],hand[PERMS[i][3]])]=handIndex;
        }
        handIndex++;
      }
    }
  }
}

.
.
.

// Now you can lookup your ordered hand index in O(1) from an unordered hand using:
int handIndex=lookup[getIndex(c0,c1,c2,c3)];

void sortInPlace(int& c0, int& c1, int& c2, int& c3) {
  SWAP_IF_GREATER_THAN(c0,c2);
  SWAP_IF_GREATER_THAN(c1,c3);
  SWAP_IF_GREATER_THAN(c0,c1);
  SWAP_IF_GREATER_THAN(c2,c3);
  SWAP_IF_GREATER_THAN(c1,c2);
}

int getHandIndex(int c0, int c1, int c2, int c3) {
  return binomial(c0,1) + binomial(c1,2) + binomial(c2,3) + binomial(c3,4);
}

sortInPlace(c0,c1,c2,c3);
int handIndex=getHandIndex(c0,c1,c2,c3);

int getHandIndex(int c0, int c1, int c2, int c3) {
  return 270724 - binomial(52-(c1+1),4) - binomial(52-(c2+1),3) - binomial(52-(c3+1),2) - binomial(52-(c4+1),1);
}

int getHandIndex(int c0, int c1, int c2, int c3) {
  return 270673 - binomial(52-(c1+1),4) - binomial(52-(c2+1),3) - binomial(52-(c3+1),2) + c4;
}

#include <iostream>

// NOTE: Must have c0 < c1 < c2 < c3.
int getHandIndex(int c0, int c1, int c2, int c3) {
  return (484902*c0 - 14699*c0*c0 + 198*c0*c0*c0 - c0*c0*c0*c0 + 4*(-7962 + 7499*c1 - 150*c1*c1 + c1*c1*c1 + 303*c2 - 3*c2*c2 + 6*c3))/24;
}

int main()
{
  int handIndex=0;
  for (int c0 = 0; c0 < 49; c0++) {	
    for (int c1 = c0+1; c1 < 50; c1++) {
      for (int c2 = c1+1; c2 < 51; c2++) {
        for (int c3 = c2+1; c3 < 52; c3++) {
          std::cout << handIndex << " = " << getHandIndex(c0,c1,c2,c3) << "\n";
          handIndex++;
        }
      }
    }
  }
}

public function EnumerateOmahaHands()
{
var hands = {};
var totalHands = 0;
for (var c0 = 0; c0 < 1; c0++) 
{	
for (var c1 = c0+1; c1 < 50; c1++) 
{
for (var c2 = c1+1; c2 < 51; c2++) 
{
for (var c3 = c2+1; c3 < 52; c3++) 
{
totalHands++;
var hand = GetCard(c0) + " " + GetCard(c1) + " " + GetCard(c2) + " " + GetCard(c3);
trace("HAND #" + totalHands + ": " + hand ); 
hands[hand] = totalHands;
}
}
}
}
return hands;
}

public function GetCard(card:Number)
{
var cardString = "";
var rankArray = "23456789TJQKA";
var suitArray = "cdhs";
cardString += rankArray.charAt(card % 13);
cardString += suitArray.charAt(card / 13);
return cardString;
}

var hands = EnumerateOmahaHands()
var handNumber = hands["2c 6s 8h Td"];

// The first 52 prime numbers.
uint32_t PRIMES[52] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239};

// NOTE: Cards can be passed in any order as each permutation will have the same unique product of primes.
// NOTE: Max key value will be: 227*229*233*239=2,894,777,321 so will fit in an unsigned 32bit integer.
uint32_t getKey(int c0, int c1, int c2, int c3) {
  return PRIMES[c0]*PRIMES[c1]*PRIMES[c2]*PRIMES[c3];
}

// Used to map from key --> hand index.
std::unordered_map<uint32_t,int> hash;

// You can now populate this as you create your ordering:
int handIndex=0;
for (int c0 = 0; c0 < 49; c0++) {	
  for (int c1 = c0+1; c1 < 50; c1++) {
    for (int c2 = c1+1; c2 < 51; c2++) {
      for (int c3 = c2+1; c3 < 52; c3++) {
        hash[getKey(c0,c1,c2,c3)]=handIndex;
        handIndex++;
      }
    }
  }
}

// Now you can lookup your ordered hand index in O(1) from an unordered hand using:
int handIndex=hash.at(getKey(c0,c1,c2,c3));