uint32_t twoM(boost::uint32_t i){
    if(i <= 9999){
        if(i <= 99){
            if(i <= 9)
                throw std::runtime_error("nahuy");
            else
                return i % 10;
        }
        else
            return (i <= 999) ? (i / 10) % 10 : (i / 100) % 10;
    }
    else{
        if(i <= 999999)
            return (i <= 99999) ? (i / 1000) % 10 : (i / 10000) % 10;
        else{
            if (i <= 99999999)
                return (i <= 9999999 ) ? (i / 100000) % 10 : (i / 1000000) % 10;
            else
                return (i <= 999999999 ) ? (i / 10000000) % 10 : (i / 100000000) % 10;
        }
    }
}
bool kaka(uint32_t i)
{
    uint32_t s = twoM(i);
    return !(s % 3);
}

int main()
{
    uint32_t i;
    std::cin >> i;
    if(i < 10)
        return 1;
    std::cout << kaka(i) << std::endl;
    return 0;
}

bool Foo(int num)
{
    if (num > 9)
        return (new[] { '3', '6', '9'}).Contains(num.ToString[1]);
    else
        return false;
}

function f(x){
var mod = x%10;
var div = x/10;
return div==0 ? false : (div>9 ? f(div) : (mod % 3 == 0));

bool check(const char *s)
{
    if (!*s) return false;
    ++s;
    return (*s=='0' || *s=='3' || *s=='6' || *s=='9');
}

O>>bool check(const char *s)
O>>{
O>>    if (!*s) return false;
O>>    ++s;
O>>    return (*s=='0' || *s=='3' || *s=='6' || *s=='9');
O>>}
O>>

В
естественной форме
(или в форме с фиксированной точкой) число представляется последовательностью десятичных цифр со знаком плюс или минус. Знак плюс можно опускать. Для отделения целой части числа от дробной используется не запятая, а точка. Ноль целых можно опускат

if (i >= 100000000) i /= 100000000;
if (i >= 10000) i /= 10000;
if (i >= 100) i /= 100;
if (i >= 10) i /= 10; // тут имеем число из 2 левых цифр
i = i % 10; // тут вторая слева цифра
if (i % 3 == 0) {
  // вторая слева цифра числа делится на 3
} else {
  // вторая слева цифра числа НЕ делится на 3
}

V>if (i >= 100000000) i /= 100000000;
V>if (i >= 10000) i /= 10000;
V>if (i >= 100) i /= 100;
V>if (i >= 10) i /= 10; // тут имеем число из 2 левых цифр
V>i = i % 10; // тут вторая слева цифра
V>if (i % 3 == 0) {
V>  // вторая слева цифра числа делится на 3
V>} else {
V>  // вторая слева цифра числа НЕ делится на 3
V>}
V>

int64_t divisor[1<<4] = { 1, 10, 100, 10*100, 10000, 10*10000, 100*10000, 10*100*10000, 100000000, 10*100000000, 100*100000000, 10*100*100000000, 10000*100000000, 10*10000*100000000, 100*10000*100000000, 10*100*10000*100000000, };
size_t mask = 0;
if (i >= 100000000) mask |= (1<<3);
if (i >= 10000)     mask |= (1<<2);
if (i >= 100)       mask |= (1<<1);
if (i >= 10)        mask |= (1<<0);
i = i/divisor[mask];
int32_t divisible_by_3[100] = {1,0,0,1,0,0,1,0,0,1,...........};
if (divisible_by_3[i]) {
  // вторая слева цифра числа делится на 3
} else {
  // вторая слева цифра числа НЕ делится на 3
}

unsigned
second_digit (unsigned x)
{
  unsigned divisor;

  if (x < 10)
    return 0;

  divisor = upow (10, ulen(x) - 2);

  return (x / divisor) % 10;
}

unsigned
upow(unsigned base, unsigned exp)
{
  unsigned result = 1;
  while (exp)
    {
      if (exp & 1)
        result *= base;
      exp >>= 1;
      base *= base;
    }

  return result;
}

unsigned
ulen (unsigned x)
{
  if (x < 10) return 1;
  if (x < 100) return 2;
  if (x < 1000) return 3;
  if (x < 10000) return 4;
  if (x < 100000) return 5;
  if (x < 1000000) return 6;
  return 7;
}

int SecondDigit( int v ) // v - наше число
{
    if ( v < 0 ) v = -v;
    if ( v < 10 ) return -1; // второй цифры нет - вернуть -1 для примера
    
    int n = (int)log10((double) v); //число цифр -1 

    return  v / (int)pow(10.0, n - 1) % 10; 
}