if ((numero > 99999999999999999999) && (numero < 10000000000000000)) //si numero tiene 21 caracteres
	{
	}

#include <bitset>
#include <iostream>
#include <string>
#include <vector>
 
class BigNum
{
  public:
 
    BigNum( int number = 0 );
 
    BigNum( const std::string& number );
 
    BigNum operator+( const BigNum& number );
 
    std::string ToBinString( ) const;
 
    std::string ToString( ) const;
 
  private:
 
    bool _negative;
    std::vector< unsigned int > _number;
 
    void Mul10AddN( unsigned int number );
 
    std::string Mul2( const std::string& number ) const;
 
    std::string Mul2AddN( const std::string& number, int carry ) const;
 
    void FromString( const std::string& number );
};
 
BigNum::BigNum( int number )
  : _negative( false )
{
  if ( number < 0 )
  {
    _negative = true;
    number = -number;
  }
  else if ( number > 0 )
    _number.push_back( number );
}
 
BigNum::BigNum( const std::string& number )
{
  FromString( number );
}
 
BigNum BigNum::operator +( const BigNum& number )
{
//  if ( number1._negative != number2._negative )
//  {
//    if ( number1._negative )
//    {
//      BigNum temp = number1;
//      temp._negative = false;
//      return number2 - temp;
//    }
//    else
//    {
//      BigNum temp = number2;
//      temp._negative = false;
//      return number1 - temp;
//    }
//  }
 
  BigNum to_return;
  to_return._negative = _negative;
 
  unsigned int carry = 0;
  unsigned int max = (_number.size( ) > number._number.size( ) )? _number.size( )
                                                                : number._number.size( );
 
  for ( unsigned int i=0; i < max; i++ )
  {
    unsigned long long temp = 0;
 
    if ( i < _number.size( ) )
      temp = static_cast< unsigned long long >( _number[ i ] );
 
    if ( i < number._number.size( ) )
      temp += static_cast< unsigned long long >( number._number[ i ] );
 
    temp += carry;
 
    to_return._number.push_back( static_cast< unsigned int >(temp & 0xFFFFFFFF) );
    carry = static_cast< unsigned int >(temp >> 32);
  }
 
  if ( carry != 0 )
    to_return._number.push_back( static_cast< unsigned int >( carry ) );
 
  return to_return;
}
 
std::string BigNum::ToBinString( ) const
{
  std::string to_return;
 
  for ( unsigned int i=_number.size( ) - 1; i < _number.size( ); i-- )
  {
    std::bitset< 32 > bits( static_cast< int >( _number[ i ] ) );
    to_return += bits.to_string( );
  }
 
  while ( to_return[ 0 ] == '0' )
    to_return.erase( to_return.begin( ) );
 
  int i = static_cast< int >( to_return.size( ) ) - 4;
  while ( i > 0 )
  {
    to_return.insert( i, 1, ' ' );
    i -= 4;
  }
  return to_return;
}
 
std::string BigNum::ToString() const
{
  std::string to_return = "0";
 
  for ( auto it = _number.rbegin( ); it != _number.rend( ); ++it )
  {
    int data = *it;
    for ( int i=0; i< 32; i++ )
    {
      to_return = Mul2AddN( to_return, (data & 0x80000000)? 1 : 0 );
      data <<= 1;
    }
  }
 
  return to_return;
}
 
void BigNum::Mul10AddN(unsigned int number)
{
  if ( _number.empty( ) )
  {
    _number.push_back( number );
    return;
  }
 
  unsigned long long carry = static_cast< unsigned long long >( number );
  unsigned long long ten = 10;
  for ( unsigned int i = 0; i < _number.size( ); i++ )
  {
    unsigned long long temp = static_cast< unsigned long long >( _number[ i ] ) * ten + carry;
 
    _number[ i ] = static_cast < unsigned int >( temp & 0xFFFFFFFF);
    carry = ( temp >> 32 );
  }
 
  if ( carry != 0 )
    _number.push_back( static_cast< unsigned int >( carry ) );
}
 
std::string BigNum::Mul2AddN(const std::string& number, int carry ) const
{
  std::string to_return;
 
  for ( auto it = number.rbegin( ); it != number.rend( ); ++it )
  {
    int temp = (*it - '0') * 2 + carry;
 
    if ( temp >= 10 )
    {
      temp -= 10;
      carry = 1;
    }
    else
      carry = 0;
 
    to_return.insert( 0, 1, temp + '0' );
  }
 
  if ( carry != 0 )
    to_return.insert( 0, 1, carry + '0' );
 
  return to_return;
}
 
void BigNum::FromString(const std::string& number)
{
  unsigned int i=0;
  if ( number[ i ] == '-' )
  {
    _negative = true;
    i++;
  }
  else
    _negative = false;
 
  _number.clear( );
 
  for ( ; i < number.length( ); i++ )
  {
    unsigned int digit = number[ i ] - 0x30;
    Mul10AddN( digit );
  }
}
 
int main( )
{
  BigNum a( 100 );
  BigNum b( "9000000000000" );
 
  BigNum c = a + b;
 
  std::cout << a.ToString( ) << std::endl
            << "+" << std::endl
            << b.ToString( ) << std::endl
            << "=" << std::endl
            << c.ToString( ) << std::endl;
 
  a = BigNum( "123456123456123456123456123456123123" );
  b = BigNum( "876543211234567876543212345678");
  c = a + b;
 
 
  std::cout << a.ToString( ) << std::endl
            << "+" << std::endl
            << b.ToString( ) << std::endl
            << "=" << std::endl
            << c.ToString( ) << std::endl;
}