Ytdyklly

I was wondering if I could solve the problem here (mostly unrelated) using only simple binary operators since it is just mapping 100 different inputs to a boolean. For this I wrote this, but I have no real way to test, and I was also hoping it could be faster.

#include <iostream>

#define MIN(a,b) ((a) < (b) ? (a) : (b))

#define MAX_VAL 100



bool CODES = {1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1};



int op(int a, int b, int index) {

    switch (index) {

        case 0: return a + b; break;

        case 1: return a - b; break;

        case 2: return a * b; break;

        case 3: return a / b; break;

        case 4: return a & b; break;

        case 5: return a | b; break;

        case 6: return a ^ b; break;

        case 7: return a % b; break;

    }

}



int main(int argc, char const *argv) {

    for (int A=1; A < 2; A++) {

        std::cout << A << std::endl;

        for (int B=1; B < 2; B++) {

            std::cout << A << " " << B << std::endl;

            for (int C=1; C < 2; C++) {

                for (int D=1; D < MAX_VAL; D++) {

                    std::cout << A << " " << B << " " << C << " " << D << std::endl;

                    for (int E=1; E < MAX_VAL; E++) {

                        for (int opA = 0; opA < 8; opA++) {

                            for (int opB = 0; opB < 8; opB++) {

                                for (int opC = 0; opC < 8; opC++) {

                                    for (int opD = 0; opD < 8; opD++) {

                                        for (int opE = 0; opE < 8; opE++) {

                                            bool good = true;

                                            int index = 1;

                                            for (bool item : CODES) {

                                                int val = op(index, A, opA);

                                                val = op(val, B, opB);

                                                val = op(val, C, opC);

                                                val = op(val, D, opD);

                                                val = op(val, E, opE);

                                                val &= 1;

                                                if (val != item) {

                                                    good = false;

                                                    break;

                                                }

                                                index++;

                                            }

                                            if (good) {

                                                std::cout<<"GOOD "<<A<<" "<<opA<<" "<<B<<" "<<opB<<" "<<C<<" "<<opC<<" "<<D<<" "<<opD<<" "<<E<<" "<<opE<<std::endl;

                                            }

                                        }

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

    }

    return 0;

}

I am specifically looking for help for optimization, but of course style, correctness, or anything else is much appreciated.