```/*
*Examples of operations using only
*The following operators: ! ~ & ^ | + << >>
*By Ynori7
*/
///////////////////////////////////////////////////
///////////////////////////////////////////////////
//return -1
int minusOne(void) {
int x=0;
return (~x);
}

///////////////////////////////////////////////////
/*
* negate : return -x
*   Example: negate(5) = -5.
*/
int negate(int x) {
return (~x)+1;
}

///////////////////////////////////////////////////
/*
* copyLSB - set all bits of result to least significant bit of x
*   Example: copyLSB(5) = 0xFFFFFFFF (all 1's), copyLSB(6) = 0x00000000
*/
int copyLSB(int x) {
return !(x & 1)+(~0);
}
///////////////////////////////////////////////////

/*
* fitsBits - return 1 if x can be represented as an
*  n-bit, two's complement integer.
*   1 <= n <= 32
*   Examples: fitsBits(5,3) = 0, fitsBits(-4,3) = 1
*/
int fitsBits(int x, int n) {
int y=x>>(n+(~0));
return !(y+1) | !y;
}
///////////////////////////////////////////////////

/*
* isEqual - return 1 if x == y, and 0 otherwise
*   Examples: isEqual(5,5) = 1, isEqual(4,5) = 0
*/
int isEqual(int x, int y) {
return !(x ^ y);
}
///////////////////////////////////////////////////

/*
* isPositive - return 1 if x > 0, return 0 otherwise
*   Example: isPositive(-1) = 0.
*/
int isPositive(int x) {
return !(x>>31) & !!x;
}
///////////////////////////////////////////////////

/*
* isGreater - if x > y  then return 1, else return 0
*   Example: isGreater(4,5) = 0, isGreater(5,4) = 1
*/
int isGreater(int x, int y) {
int a=x>>30, b=y>>30;
int q=~(1<<31);
int c=x&q, d=y&q;
int z=a+(~b + 1);
int h=c+(~d + 1);
int p=!z;
return ((!(z>>31) & !p) | (p & (!(h>>31)))) ^ !(x ^ y);
}
///////////////////////////////////////////////////

/*
* logicalShift - shift x to the right by n, using a logical shift
*   Can assume that 1 <= n <= 31
*   Examples: logicalShift(0x87654321,4) = 0x08765432
*/
int logicalShift(int x, int n) {
int y=(1<<31);
int q= (~y) & x;
int p= q>>n;
int k= y&x;
return ((k>>31) & (1<<(31+(~n+1)))) | p;
}
///////////////////////////////////////////////////

/*
* leastBitPos - return a mask that marks the position of the
*               least significant 1 bit. If x == 0, return 0
*   Example: leastBitPos(96) = 0x20
*/
int leastBitPos(int x) {
return (~x+1)&x;
}
///////////////////////////////////////////////////

/*
* bitParity - returns 1 if x contains an odd number of 0's
*   Examples: bitParity(5) = 0, bitParity(7) = 1
*/
int bitParity(int x) {
int a = x ^ (x << 16);
int b = a ^ (a << 8);
int c = b ^ (b << 4);
int d = c ^ (c << 2);
int e = d ^ (d << 1);
return !!(e & (1<<31));
}
```