//types and constants used in the functions below

typedef unsigned __int64 uint64;  //assume this gives 64-bits
const uint64 m1 = 0x5555555555555555; //binary: 0101...
const uint64 m2 = 0x3333333333333333; //binary: 00110011..
const uint64 m4 = 0x0f0f0f0f0f0f0f0f; //binary:  4 zeros,  4 ones ...
const uint64 m8 = 0x00ff00ff00ff00ff; //binary:  8 zeros,  8 ones ...
const uint64 m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ...
const uint64 m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones ...
const uint64 hff = 0xffffffffffffffff; //binary: all ones
const uint64 h01 = 0x0101010101010101; //the sum of 256 to the power of 0,1,2,3...

//This is a naive implementation, shown for comparison,
//and to help in understanding the better functions.
//It uses 24 arithmetic operations (shift, add, and).
int popcount_1(uint64 x) {
    x = (x & m1 ) + ((x >>  1) & m1 ); //put count of each  2 bits into those  2 bits 
    x = (x & m2 ) + ((x >>  2) & m2 ); //put count of each  4 bits into those  4 bits 
    x = (x & m4 ) + ((x >>  4) & m4 ); //put count of each  8 bits into those  8 bits 
    x = (x & m8 ) + ((x >>  8) & m8 ); //put count of each 16 bits into those 16 bits 
    x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits 
    x = (x & m32) + ((x >> 32) & m32); //put count of each 64 bits into those 64 bits 
    return x;
}

//This uses fewer arithmetic operations than any other known  
//implementation on machines with slow multiplication.
//It uses 17 arithmetic operations.
int popcount_2(uint64 x) {
    x -= (x >> 1) & m1;             //put count of each 2 bits into those 2 bits
    x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 
    x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits 
    x += x >>  8;  //put count of each 16 bits into their lowest 8 bits
    x += x >> 16;  //put count of each 32 bits into their lowest 8 bits
    x += x >> 32;  //put count of each 64 bits into their lowest 8 bits
    return x &0xff;
}

//This uses fewer arithmetic operations than any other known  
//implementation on machines with fast multiplication.
//It uses 12 arithmetic operations, one of which is a multiply.
int popcount_3(uint64 x) {
    x -= (x >> 1) & m1;             //put count of each 2 bits into those 2 bits
    x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits 
    x = (x + (x >> 4)) & m4;        //put count of each 8 bits into those 8 bits 
    return (x * h01)>>56;  //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... 
}

#include <iostream>
using namespace std;
int main() {
    float in_cm;
    float in_inches;
    const float EPSINON = 0.00001;
    cin >> in_cm >> in_inches;
    in_inches = in_inches * 2.54;
    if (- EPSINON<=in_cm-in_inches && in_cm-in_inches <= EPSINON) {
        cout << "YES";
    }
    else {
        cout << "NO";
    }
}

#include <stdio.h>
#include <iostream>
using namespace std;
int n, i;
int a[100];
int findsigular (int a[], int len) {
    int res = 0;
    int j = 0;
    for (j=0;j<len;j++) {
        res = res ^ a[j];
    }
    return res;
}
int main() {
    cin >> n;
    for (i=0;i<n;i++) {
            cin >> a[i];
    }
    cout << findsigular(a,n);
}

    int getSingle(int arr[], int n)
    {
        int ones = 0, twos = 0 ;
    
        int common_bit_mask;
    
        // Let us take the example of {3, 3, 2, 3} to understand this
        for( int i=0; i< n; i++ )
        {
            /* The expression "one & arr[i]" gives the bits that are
            there in both 'ones' and new element from arr[].  We
            add these bits to 'twos' using bitwise OR
    
            Value of 'twos' will be set as 0, 3, 3 and 1 after 1st,
            2nd, 3rd and 4th iterations respectively */
            twos  = twos | (ones & arr[i]);
    
    
            /* XOR the new bits with previous 'ones' to get all bits
            appearing odd number of times
    
            Value of 'ones' will be set as 3, 0, 2 and 3 after 1st,
            2nd, 3rd and 4th iterations respectively */
            ones  = ones ^ arr[i];
    
    
            /* The common bits are those bits which appear third time
            So these bits should not be there in both 'ones' and 'twos'.
            common_bit_mask contains all these bits as 0, so that the bits can 
            be removed from 'ones' and 'twos'   
    
            Value of 'common_bit_mask' will be set as 00, 00, 01 and 10
            after 1st, 2nd, 3rd and 4th iterations respectively */
            common_bit_mask = ~(ones & twos);
    
    
            /* Remove common bits (the bits that appear third time) from 'ones'
                
            Value of 'ones' will be set as 3, 0, 0 and 2 after 1st,
            2nd, 3rd and 4th iterations respectively */
            ones &= common_bit_mask;
    
    
            /* Remove common bits (the bits that appear third time) from 'twos'
    
            Value of 'twos' will be set as 0, 3, 1 and 0 after 1st,
            2nd, 3rd and 4th itearations respectively */
            twos &= common_bit_mask;
    
            // uncomment this code to see intermediate values
            //printf (" %d %d n", ones, twos);
        }
    
        return ones;
    }

#include <iostream>
#include <string>
#include <math.h>
using namespace std;
int i, sum;
int main() {
    string hexd;
    cin >> hexd;
    int n = hexd.length();
    sum = 0;
    for (i=n-1;i>=0;i--) {
        if (hexd[i]>='0' && hexd[i] <= '9') {
            sum+=(hexd[i]-48)*pow(16,n-i-1);
        }
        else if (hexd[i]>='A' && hexd[i]<='F') {
            sum+=(hexd[i]-55)*pow(16,n-i-1);
        }
    }
    cout << sum;
}

#include <iostream>
#include <cmath>
#include <string.h>
using namespace std;
int main() {
    char a[105],ch;
    int k, i, j;
    cout << "please enter Key(k):";
    cin >> k;
    cout << "please select encryption(0) or decryption(1): ";
    cin >> ch;
    if (ch=='0') {
        cout << "please enter Plaintext string:";
        cin >> a;
        for (i=0; i<strlen(a); i++) {
            if (a[i]>='a' && a[i]<='z') {
                cout << (char)((a[i]-'a'+k)%26 + 'a');
            }
            else if (a[i]>='A' && a[i]<='Z') {
                cout << (char)((a[i]-'A'+k)%26 + 'A');
            }
        }
    }
    else if (ch=='1') {
        cout << "please enter cyphertext string: ";
        cin >> a;
        for (j=0;j<strlen(a);j++) {
            if (a[j]>='a' && a[j]<='z') {
                cout << (char)((a[j]-'a'+26-k)%26 + 'a');
            }
            else if (a[j]>='A' && a[j]<='Z') {
                cout << (char)((a[j]-'A'+26-k)%26+'A');
            }
        }
    }
}

#include <iostream>
#include <stack>
#include <algorithm>
#include <vector>
using namespace std;
enum AnalysisType:unsigned char{FLOAT=0x01,OPERATOR=0x02};
struct ItemValue
{
    union ValueUnion
    {
        float fdigit;
        char symbol;
    };
    AnalysisType type;
    ValueUnion value;
};
//简单的int加减乘除
int GetPriority(char symbol)
{
    switch (symbol)
    {
    case '+':
    case '-':
        return 0;
    case '*':
    case '/':
        return 1;
    case '(':
    case ')':
        return 2;
    }
    return -1;
}

bool IsOperator(char symbol)
{
    switch (symbol)
    {
        case '+':
        case '-':
        case '*':
        case '/':
        case '(':
        case ')':
        return true;
    }
    return false;
}
//转成vector存
void wordsAnalysis(char*pIn, vector<ItemValue>&vec)
{
    int nCount = strlen(pIn);
    int nIndex = 0;
    while (nIndex<nCount)
    {
        ItemValue item = { FLOAT,0};
//处理操作符
        if (IsOperator(pIn[nIndex]))//如果是操作符
        {
            item.type = OPERATOR;
            item.value.symbol = pIn[nIndex];
            vec.push_back(item);
        }
//处理数字
        int nTemp = nIndex;
        char nBuffer[20] = {0};//20位
        while (isdigit(pIn[nTemp]) || '.'==pIn[nTemp])
        {   
            nBuffer[nTemp - nIndex]=pIn[nTemp];
            ++nTemp;
        }
        if (nTemp != nIndex)
        {
            item.value.fdigit = atof(nBuffer);
            vec.push_back(item);
        }
//////////
        if (nTemp != nIndex)
            nIndex += strlen(nBuffer);
        else
            ++nIndex;
    }
}
//中缀转后缀
void midToLast(vector<ItemValue> & vecIn, vector<ItemValue> & vecOut)
{
    ItemValue item{ OPERATOR ,0.0f };
    stack<char> stack_symbol;
    for_each(std::begin(vecIn), std::end(vecIn), [&](ItemValue &it) {
        if (FLOAT == it.type )
        {
            vecOut.push_back(it);
        }
        else if (OPERATOR == it.type)
        {
            if (')' == it.value.symbol)
            {
                while (!stack_symbol.empty())
                {
                    if (stack_symbol.top() == '(')
                    {
                        stack_symbol.pop();
                        return;
                    }
                    item.value.symbol = stack_symbol.top();
                    stack_symbol.pop();
                    vecOut.push_back(item);
                }
            }
            if (!stack_symbol.empty())
            {
                if (GetPriority(stack_symbol.top()) - GetPriority(it.value.symbol) >= 0 && stack_symbol.top()!='(')
                {
                    item.value.symbol = stack_symbol.top();
                    stack_symbol.pop();
                    vecOut.push_back(item);
                }
            }
            if(')' != it.value.symbol)
                stack_symbol.push(it.value.symbol);
        }
    });
    //把栈里的操作符提出来
    while (!stack_symbol.empty())
    {
        item.value.symbol = stack_symbol.top();
        stack_symbol.pop();
        vecOut.push_back(item);
    }
}
//计算
float Calculate(vector<ItemValue>& vec)
{
    float fResult=0.0f;
    stack<ItemValue> stack_value;
    for_each(std::begin(vec), std::end(vec), [&](ItemValue &it) {
        if (FLOAT == it.type)
        {
            stack_value.push(it);
        }
        else if(OPERATOR == it.type)
        {
            ItemValue Value1, Value2 ;
            Value2=stack_value.top();
            stack_value.pop();

            Value1=stack_value.top();
            stack_value.pop();

            switch (it.value.symbol)
            {
            case '+':
                Value1.value.fdigit += Value2.value.fdigit;
                break;
            case '-':
                Value1.value.fdigit -= Value2.value.fdigit;
                break;
            case '*':
                Value1.value.fdigit *= Value2.value.fdigit;
                break;
            case '/':
                Value1.value.fdigit /= Value2.value.fdigit;
                break;
            }
            Value1.type = FLOAT;
            stack_value.push(Value1);
        }
    });
    fResult = stack_value.top().value.fdigit;
    return fResult;
}

int main()
{
    char buffer[64] = {0};
    vector<ItemValue> vecIn,vecOut;
    cout << "请输入表达式：";
    cin >> buffer;
    wordsAnalysis(buffer, vecIn);//拆分数据
    midToLast(vecIn,vecOut);//转到后缀表达式，vecOut内
    cout << "中缀到后缀：";
    for_each(std::begin(vecOut), std::end(vecOut), [&](ItemValue &it) {
        FLOAT == it.type?       
        cout << it.value.fdigit << "  ":
        cout << (char)it.value.symbol << "  ";
    });
    cout <<endl<<"计算结果：" << Calculate(vecOut)<<endl ;
    return 0;
}

#include <string>
#include <iostream>
using namespace std;
float calculate(float Operand1, float Operand2, char Operator) {
    float res = 0 ;
    if (Operator == '+') {
        res = Operand1 + Operand2;
    }
    else if (Operator == '-') {
        res = Operand1 - Operand2;
    }
    return res;
}

float EE(const string& str) {
    float Operand1 = 0;
    float Operand2 = 0;
    char Operator = 0;
    for (size_t i=0, size=str.size(); i<size; ++i) {
        const char& ch = str[i];
        if ('0'<=ch && ch<='9') {
            if (Operator == 0) {
                Operand1 = Operand1*10 + ch - '0';
            }
            else {
                Operand2 = Operand2*10 + ch - '0';
            }
        }
        else if (ch=='+' || ch=='-') {
            if (Operator == 0) {
                Operator = ch;
            }
            else {
                Operand1 = calculate(Operand1, Operand2, Operator);
                Operand2 = 0;
                Operator = ch;
            }
        }
    }
    Operand1 = calculate(Operand1, Operand2, Operator);
    return Operand1;
}
int main() {
    string str;
    cin >> str;
    float Res = EE(str);
    cout << str << "=" << Res << endl;
}