// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int A, int B, int C) {
        // write your code in Java SE 8
    }
}

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(int A, int B, int C) {
    // write your code in C++14 (g++ 6.2.0)
}

int solution(int A, int B, int C) {
    int nA = 0;
    int nB = 0;
    int nC = 0;

    int nAorB = 0;
    int nAorC = 0;
    int nBorC = 0;
    int nAorBorC = 0;

    int AorB = A | B;
    int AorC = A | C;
    int BorC = B | C;
    int AorBorC = A | B | C;

    // each digit zero within the number binary representation generates 2 possibilities (0 and 1)
    // thus, we need only count the number of zeroes and get # possibilities as (2 power number_of_zeroes)
    // the only tricky is avoid duplicates. In order to avoid it, we can use the basic set relation:
    // #(A or B) = #(A) + #(B) - #(A and B)

    for (int i = 0; i < 30; i++) {

        // shift right A by i and check if the rightmost digit is 0
        if (((A >> i) & 0x01) == 0) nA++;
        if (((B >> i) & 0x01) == 0) nB++;
        if (((C >> i) & 0x01) == 0) nC++;

        if (((AorB >> i) & 0x01) == 0) nAorB++;
        if (((AorC >> i) & 0x01) == 0) nAorC++;
        if (((BorC >> i) & 0x01) == 0) nBorC++;

        if (((AorBorC >> i) & 0x01) == 0) nAorBorC++;

    }

    // result = + #(possibilities of A) + #(possibilities of B) + #(possibilities of C) 
    //          - #(possibilities of A or B) - #(possibilities of B or C) - #(possibilities of A or C)
    //          + #(possibilities of A or B or C)

    //int result = (1 << nA) + (1 << nB) + (1 << nC) - (1 << nAorB) - (1 << nAorC) - (1 << nBorC) + (1 << nAorBorC);

    // reordering the sum up in order to avoid overflow
    int result = (1 << nA) - (1 << nAorB) - (1 << nAorC) - (1 << nBorC) + (1 << nB) + (1 << nC) + (1 << nAorBorC);

    return result;
}

int solution(int A, int B, int C) {
    int nA = 0;
    int nB = 0;
    int nC = 0;

    int nAorB = 0;
    int nAorC = 0;
    int nBorC = 0;
    int nAorBorC = 0;

    int AorB = A | B;
    int AorC = A | C;
    int BorC = B | C;
    int AorBorC = A | B | C;

    // each digit zero within the number binary representation generates 2 possibilities (0 and 1)
    // thus, we need only count the number of zeroes and get # possibilities as (2 power number_of_zeroes)
    // the only tricky is avoid duplicates. In order to avoid it, we can use the basic set relation:
    // #(A or B) = #(A) + #(B) - #(A and B)

    for (int i = 0; i < 30; i++) {

        // shift right A by i and check if the rightmost digit is 0
        if (((A >> i) & 0x01) == 0) nA++;
        if (((B >> i) & 0x01) == 0) nB++;
        if (((C >> i) & 0x01) == 0) nC++;

        if (((AorB >> i) & 0x01) == 0) nAorB++;
        if (((AorC >> i) & 0x01) == 0) nAorC++;
        if (((BorC >> i) & 0x01) == 0) nBorC++;

        if (((AorBorC >> i) & 0x01) == 0) nAorBorC++;

    }

    // result = + #(possibilities of A) + #(possibilities of B) + #(possibilities of C) 
    //          - #(possibilities of A or B) - #(possibilities of B or C) - #(possibilities of A or C)
    //          + #(possibilities of A or B or C)

    //int result = (1 << nA) + (1 << nB) + (1 << nC) - (1 << nAorB) - (1 << nAorC) - (1 << nBorC) + (1 << nAorBorC);

    // reordering the sum up in order to avoid overflow
    int result = (1 << nA) - (1 << nAorB) - (1 << nAorC) - (1 << nBorC) + (1 << nB) + (1 << nC) + (1 << nAorBorC);

    return result;
}

int solution(int A, int B, int C) {
    int nA = 0;
    int nB = 0;
    int nC = 0;

    int nAorB = 0;
    int nAorC = 0;
    int nBorC = 0;
    int nAorBorC = 0;

    int AorB = A | B;
    int AorC = A | C;
    int BorC = B | C;
    int AorBorC = A | B | C;

    // each digit zero within the number binary representation generates 2 possibilities (0 and 1)
    // thus, we need only count the number of zeroes and get # possibilities as (2 power number_of_zeroes)
    // the only tricky is avoid duplicates. In order to avoid it, we can use the basic set relation:
    // #(A or B) = #(A) + #(B) - #(A and B)

    for (int i = 0; i < 30; i++) {

        // shift right A by i and check if the rightmost digit is 0
        if (((A >> i) & 0x01) == 0) nA++;
        if (((B >> i) & 0x01) == 0) nB++;
        if (((C >> i) & 0x01) == 0) nC++;

        if (((AorB >> i) & 0x01) == 0) nAorB++;
        if (((AorC >> i) & 0x01) == 0) nAorC++;
        if (((BorC >> i) & 0x01) == 0) nBorC++;

        if (((AorBorC >> i) & 0x01) == 0) nAorBorC++;

    }

    // result = + #(possibilities of A) + #(possibilities of B) + #(possibilities of C) 
    //          - #(possibilities of A or B) - #(possibilities of B or C) - #(possibilities of A or C)
    //          + #(possibilities of A or B or C)

    //int result = (1 << nA) + (1 << nB) + (1 << nC) - (1 << nAorB) - (1 << nAorC) - (1 << nBorC) + (1 << nAorBorC);

    // reordering the sum up in order to avoid overflow
    int result = (1 << nA) - (1 << nAorB) - (1 << nAorC) - (1 << nBorC) + (1 << nB) + (1 << nC) + (1 << nAorBorC);

    return result;
}