MSVC 2015 оптимизация в компиляторе

#include <fstream>
#include <iostream>
#include <time.h>
#include "windows.h"
using namespace std;
 
//this program is a poker hand evaluator test
//there is EvalF() function which takes 7 cards as numbers from 0 to 51 and returns a number from 1 to 4824. Lets call it equivalence class or EQ. The less the number the better the hand.
//so the speed test here is enumeration through all possible C(52,7)=~134M possible combinations of 7-card poker hands
//the main work is done here in this loop of 134M iterations
#define LOOP_7_CARDS(X) for (c1 = 0; c1 < 52; c1++) {      \
                        for (c2 = c1+1; c2 < 52; c2++) {    \
                        for (c3 = c2+1; c3 < 52; c3++) {    \
                        for (c4 = c3+1; c4 < 52; c4++) {    \
                        for (c5 = c4+1; c5 < 52; c5++) {    \
                        for (c6 = c5+1; c6 < 52; c6++) {    \
                        for (c7 = c6+1; c7 < 52; c7++) {    \
                            (X);}}}}}}}                 \
//these are for processing of results
//names of poker combinations
    const char* HandRanks[]={
    "High Card =        ",
    "One Pair =         ",
    "Two Pairs =        ",
    "Three of a Kind =  ",
    "Straight =         ",
    "Flushes =          ",
    "Fullhouse =        ",
    "Four of a Kind =   ",
    "Straight Flush =   "};
 
    int IDcount[4825] = {0};//counts how many times we had specific EQ, like IDcount[EQ]++
    int _count[10] = {0};//counter for combinations
    int total = 0;       //total hands evaluated
    int c1, c2, c3, c4, c5, c6,c7; //cards
    __int64 clocksused; //variables for timings
    clock_t timer;
    LARGE_INTEGER timings, endtimings;
 
void start_clock(){
        clock_t timer = clock();    // start regular clock
        QueryPerformanceCounter(&timings);   // start High Precision clock
    }
 
void stop_clock(){
    QueryPerformanceCounter(&endtimings);  // end the high precision clock
    timer = clock() - timer;                  // end the regular clock
    clocksused = (__int64)endtimings.QuadPart - (__int64) timings.QuadPart;
    }
//transforms EQ counter IDcount[] into human readable combination counter _count[],
// so abbreviations stand for poker combinations like high card, one pair, two pair, etc.
void check_sum () {
    for(int i = 1; i < 11; i++)        _count[8]+=IDcount[i]; //SF
    for(int i = 11; i < 167; i++)      _count[7]+=IDcount[i]; //FK  
    for(int i = 167; i < 323; i++)     _count[6]+=IDcount[i]; //FH  
    for(int i = 323; i < 1600; i++)    _count[5]+=IDcount[i]; //FL  
    for(int i = 1600; i < 1610; i++)   _count[4]+=IDcount[i]; //ST  
    for(int i = 1610; i < 2185; i++)   _count[3]+=IDcount[i]; //TK  
    for(int i = 2185; i < 2948; i++)   _count[2]+=IDcount[i]; //TP  
    for(int i = 2948; i < 4418; i++)   _count[1]+=IDcount[i]; //OP  
    for(int i = 4418; i < 4825; i++)   _count[0]+=IDcount[i]; //HC  
}
 
void validation_time (){
    printf("\nValidation seconds = %.4lf\nTotal HighPrecision Clocks = %I64d\nHighPrecision clocks per lookup = %lf\n", (double)timer/CLOCKS_PER_SEC, clocksused, (double) clocksused /  133784.560) ;
}   
// display results
void results () {
    check_sum();
    for(int i = 0; i < 9; i++) {
        cout << HandRanks[i]<<_count[i]<<endl;
        total+=_count[i];
    }
    cout << "Total =            " << total;
    validation_time ();
}
//macro for reading binary file with lookup tables
#define INIT_HR {if (!initHR()){  printf("Problem Opening HRLUTfinal.dat\n");return 0;}}
#define ULL long long   
    //lookup tables
    short EL0[13];
    short EL1[13][13];
    short EL2[91][13];
    short EL3[455][13];
    short EL4[1820][13];
    short EL5[6188][13];
    short EL6[18564][13];
    short flushes[8192];
 
    ULL  hand, //given hand
         x=1;   //64bit 1
//this function reads lookup tables from binary file and puts them to EL0...EL6 arrays
int initHR (){
    errno_t err;
    FILE * f1;
    err = fopen_s(&f1, "HRLUTfinal.dat", "rb");
 
    if (!f1) {                                    
        printf("Problem Opening HRLUTfinal.dat\n");
        return 0;
    }
 
    size_t   read_lut = fread(EL0, sizeof(EL0), 1, f1);
             read_lut = fread(EL1, sizeof(EL1), 1, f1);
             read_lut = fread(EL2, sizeof(EL2), 1, f1);
             read_lut = fread(EL3, sizeof(EL3), 1, f1);
             read_lut = fread(EL4, sizeof(EL4), 1, f1);
             read_lut = fread(EL5, sizeof(EL5), 1, f1);
             read_lut = fread(EL6, sizeof(EL6), 1, f1);
             read_lut = fread(flushes,sizeof(flushes),1,f1);
 
    fclose(f1);
    return 1;
}
//this function returns a value for a 7 card hand as if no suits exist which is most common case in poker
    inline short HRoffsuit (short c1, short c2, short c3, short c4, short c5, short c6, short c7){ 
        return EL6[EL5[EL4[EL3[EL2[EL1[EL0[c1%13]][c2%13]][c3%13]][c4%13]][c5%13]][c6%13]][c7%13]; 
    }
 
    inline short EvalF (short c1, short c2, short c3, short c4, short c5, int c6, short c7){
        hand=(x<<c1)|(x<<c2)|(x<<c3)|(x<<c4)|(x<<c5)|(x<<c6)|(x<<c7);//add cards to 52-bit mask
        short m,n;
        m= flushes[hand&0x1fff]|flushes[(hand>>13)&0x1fff]|        //split 52-bit mask into 13-bit pieces for each suit
            flushes[(hand>>26)&0x1fff]|flushes[(hand>>39)&0x1fff];//and use each piece as index to flushes array
    n=  HRoffsuit(c1,c2,c3,c4,c5,c6,c7);                     //comb trough tables having ranks only disregarding suits
    if (!m) m=n;                                            //if no flush detected then return our second value 
        return m;
    }
//main function is pretty much pseudocode   
int main(){
 
    //read lookup table from .DAT file
    INIT_HR;
 
    start_clock();
 
    LOOP_7_CARDS(IDcount[EvalF(c1,c2,c3,c4,c5,c6,c7)]++);
 
    stop_clock();
 
    // display results
    results();
    system("pause");
    return 0;
 
}