Има няколко специфични поведения, които трябва да се запомнят при работа с битове, проблема е че информацията за тях е много рядка и често води до много главоблъсканици. Проблема специфично е със bitwise shift операторите >> и <<. Важното правило тук е че позициите с които ще се измести левия операнд зависят директно от типа му. Примерно
1 << 31 ще работи защото 1 по подразбиране е int, но 1 << 32 няма да работи правилно, реално резултата от тази операция би бил 1 защото bitwise shift оператора измества левия операнд само с най-десните X бита на десния операнд като Х зависи от типа на левия операнд. При int ще се прочетат само най-десните 5 бита (стойностите които могат да се образуват с 5 бита 0-31) при лонг ще се броят само най-десните 6 бита (0-63). Това може да се види ако погледнем битовата репрезентация на 31 и на 32, 31 = 11111, 32 = 100000. Със знанието че ще се прочетат само най-десните 5 бита може да видим че в първия случай с 31 числото образувано от първите 5 бита е 31, във втория случай обаче числото образувано от първите 5 бита е 0 (защото всичките са нули) и изместването реалистично би било 1 << 0 което е равно на 1. Иначе казано на кратко проблема е тук колега:

number = number & ~(1 << k);

за да работи правилно тази операция 1 трябва да се кастне ръчно към long =>

number = number & ~((long)1 << k);

внимавай само къде ще си сложиш каста, точно единицата трябва да се кастне към long горният код ще работи, но този примерно няма:

number = number & ~(long)(1 << k);

ето статията от MSDN за bitwise shift операторите тук.
Друга специфика която бих споменал е че резултата от аритметични операции с типове по малки от int не връщат собствения си тип а връщат int, примерно byte a = byte b + byte c; не е валиден код това е защото компилатора на C# реално няма оператори за събиране на byte-ове и без да казва ги каства към int и извършва операцията с int-ове, ако искаш да разбереш повече по въпроса ето ти линк към темата в stackoverflow.