

import dataclasses
import enum
import functools
import math
import re

# The following script is adapted from the script of TaPas.
# Original: https://github.com/google-research/tapas/master/wikisql_utils.py
from typing import Any, List, Text


_SCREAMING_SNAKE_CASE							 =			'''none'''
_SCREAMING_SNAKE_CASE							 =			'''none'''





def  _snake_case		(snake_case_					:     List[str]    ,       snake_case_					:     List[Any]  )							->		Optional[Any]:
  __UpperCAmelCase	:  List[str]		=     value.split(snake_case_  )
  return len(snake_case_  ) > 1 and any((len(snake_case_  ) == 3 for x in split)  )





def  _snake_case		(snake_case_					:     Tuple  )							->		List[Any]:
  if isinstance(snake_case_    ,       snake_case_  ):
    return value
  if isinstance(snake_case_    ,       snake_case_  ):
    return float(snake_case_  )
  if not isinstance(snake_case_    ,       snake_case_  ):
    raise ValueError('Argument value is not a string. Can\'t parse it as float'  )
  __UpperCAmelCase	:  Optional[int]		=     value

  try:
    # Example: 1,000.7
    if "." in sanitized and "," in sanitized:
      return float(sanitized.replace(','    ,       ''  )  )
    # 1,000
    if "," in sanitized and _split_thousands(','    ,       snake_case_  ):
      return float(sanitized.replace(','    ,       ''  )  )
    # 5,5556
    if "," in sanitized and sanitized.count(','  ) == 1 and not _split_thousands(','    ,       snake_case_  ):
      return float(sanitized.replace(','    ,       '.'  )  )
    # 0.0.0.1
    if sanitized.count('.'  ) > 1:
      return float(sanitized.replace('.'    ,       ''  )  )
    # 0,0,0,1
    if sanitized.count(','  ) > 1:
      return float(sanitized.replace(','    ,       ''  )  )
    return float(snake_case_  )
  except ValueError:
    # Avoid adding the sanitized value in the error message.
    raise ValueError('Unable to convert value to float'  )





def  _snake_case		(snake_case_					:     Tuple  )							->		List[str]:
  if answer is None:
    return None
  try:
    __UpperCAmelCase	:  Dict		=     convert_to_float(snake_case_  )
    if isinstance(snake_case_    ,       snake_case_  ) and math.isnan(snake_case_  ):
      return None
    return value
  except ValueError:
    return answer.lower()


_SCREAMING_SNAKE_CASE							 =			{
    '''text''': lambda x: x,
    '''real''': convert_to_float,
}


class      lowerCamelCase_ (			enum.Enum):
 _lowerCAmelCase									=	0
 _lowerCAmelCase									=	1
 _lowerCAmelCase									=	2
 _lowerCAmelCase									=	3
 _lowerCAmelCase									=	4
 _lowerCAmelCase									=	5



class      lowerCamelCase_ (			enum.Enum):
 _lowerCAmelCase									=	0
 _lowerCAmelCase									=	1
 _lowerCAmelCase									=	2



@dataclasses.dataclass
class      lowerCamelCase_ :
 _lowerCAmelCase									=	42
 _lowerCAmelCase									=	42
 _lowerCAmelCase									=	42



_SCREAMING_SNAKE_CASE							 =			re.compile(r'''\w+|[^\w\s]+''', re.UNICODE | re.MULTILINE | re.DOTALL)





def  _snake_case		(snake_case_					:     Union[str, Any]  )							->		Any:
  return list(_TOKENIZER.findall(x.lower()  )  )





def  _snake_case		(snake_case_					:     int    ,       snake_case_					:     Optional[int]    ,       snake_case_					:     Tuple  )							->		Optional[int]:
  if operator == _Operator.EQUALS:
    return src == tgt
  elif operator == _Operator.GREATER:
    return src > tgt
  elif operator == _Operator.LESSER:
    return src < tgt
  raise ValueError(F"Unknown operator: {operator}"  )





def  _snake_case		(snake_case_					:     Tuple    ,       snake_case_					:     Optional[Any]    ,       snake_case_					:     int  )							->		Optional[Any]:
  __UpperCAmelCase	:  List[Any]		=     table['types']
  return _TYPE_CONVERTER[types[column]](snake_case_  )





def  _snake_case		(snake_case_					:     Dict  )							->		int:
  return isinstance(snake_case_    ,       snake_case_  )





def  _snake_case		(snake_case_					:     Any    ,       snake_case_					:     int    ,       snake_case_					:     int  )							->		Optional[Any]:
  for cond in conditions:
    __UpperCAmelCase	:  Any		=     row[cond.column]

    __UpperCAmelCase	:  Union[str, Any]		=     _parse_value(snake_case_    ,       cond.column    ,       cond.cmp_value  )

    if _is_string(snake_case_  ) and _is_string(snake_case_  ):
      __UpperCAmelCase	:  str		=     _normalize_for_match(snake_case_  )
      __UpperCAmelCase	:  Optional[Any]		=     _normalize_for_match(snake_case_  )

    if not isinstance(snake_case_    ,       type(snake_case_  )  ):
      raise ValueError('Type difference {} != {}'.format(type(snake_case_  )    ,       type(snake_case_  )  )  )

    if not _compare(cond.operator    ,       snake_case_    ,       snake_case_  ):
      return False
  return True





def  _snake_case		(snake_case_					:     List[str]    ,       snake_case_					:     Dict    ,       snake_case_					:     Union[str, Any]  )							->		List[str]:
  if not answer_coordinates:
    if aggregation_op == _Aggregation.COUNT:
      return 0.0
    else:
      return EMPTY_ANSWER_AGG

    # Count can support non numeric answers.
  if aggregation_op == _Aggregation.COUNT:
    return float(len(snake_case_  )  )

  # If we have just one answer, if float returns it or try a conversion.
  __UpperCAmelCase	:  Any		=     [table['rows'][i][j] for (i, j) in answer_coordinates]
  if len(snake_case_  ) == 1:
    try:
      return convert_to_float(values[0]  )
    except ValueError as e:
      if aggregation_op != _Aggregation.NONE:
        raise e

  if aggregation_op == _Aggregation.NONE:
    return None

  # Other aggregation only support numeric values. Bail out if we have strings.
  if not all((isinstance(snake_case_    ,       (int, float)  ) for v in values)  ):
    return None

  if aggregation_op == _Aggregation.SUM:
    return float(sum(snake_case_  )  )
  elif aggregation_op == _Aggregation.AVERAGE:
    return sum(snake_case_  ) / len(snake_case_  )
  else:
    raise ValueError(F"Unknown aggregation: {aggregation_op}"  )





def  _snake_case		(snake_case_					:     int    ,       snake_case_					:     Union[str, Any]  )							->		Tuple:
  __UpperCAmelCase	:  int		=     sql_query['agg']
  if aggregation_op_index >= 3:
    __UpperCAmelCase	:  Union[str, Any]		=     _Aggregation(snake_case_  )
  else:
    __UpperCAmelCase	:  List[Any]		=     _Aggregation.NONE

  __UpperCAmelCase	:  Dict		=     sql_query['sel']
  __UpperCAmelCase	:  Optional[int]		=     [
      _Condition(snake_case_    ,       _Operator(snake_case_  )    ,       snake_case_  )
      for column, operator, cmp_value in zip(
          sql_query['conds']['column_index']    ,       sql_query['conds']['operator_index']    ,       sql_query['conds']['condition']  )
  ]

  __UpperCAmelCase	:  Optional[Any]		=     []
  for row in range(len(table['rows']  )  ):
    if _respect_conditions(snake_case_    ,       table['rows'][row]    ,       snake_case_  ):
      indices.append((row, target_column)  )

  if not indices:
    return [], aggregation_op

  if len(snake_case_  ) == 1:
    return indices, aggregation_op

  # Parsing of MIN/MAX.
  if aggregation_op_index in (1, 2):
    __UpperCAmelCase	:  str		=     {2: min, 1: max}
    __UpperCAmelCase	:  Dict		=     [(table['rows'][i][j], index) for index, (i, j) in enumerate(snake_case_  )]
    __UpperCAmelCase	:  Optional[int]		=     functools.reduce(operators[sql_query['agg']]    ,       snake_case_  )

    __UpperCAmelCase	:  Optional[int]		=     [indices[reduced[1]]]
    return ret, _Aggregation.NONE

  return indices, aggregation_op





def  _snake_case		(snake_case_					:     int    ,       snake_case_					:     Any    ,       snake_case_					:     Optional[int]  )							->		List[Any]:
  if float_answer is not None:
    return [str(snake_case_  )]
  return [str(table['real_rows'][r][c]  ) for r, c in answer_coordinates]







def  _snake_case		(snake_case_					:     Union[str, Any]    ,       snake_case_					:     Optional[int]  )							->		List:
  __UpperCAmelCase,			__UpperCAmelCase	:  Union[str, Any]		=     _get_answer_coordinates(snake_case_    ,       snake_case_  )
  __UpperCAmelCase	:  Optional[int]		=     _get_float_answer(snake_case_    ,       snake_case_    ,       snake_case_  )
  __UpperCAmelCase	:  Optional[int]		=     _get_answer_text(snake_case_    ,       snake_case_    ,       snake_case_  )
  # keep the original data the same with TaPas
  if len(snake_case_  ) == 0:
    __UpperCAmelCase	:  Optional[Any]		=     [EMPTY_ANSWER]
  return answer_text













'''simple docstring'''






def 							_SCREAMING_SNAKE_CASE	(					)     ->			int:







   """simple docstring"""

   for a in range(3_00	):
      for b in range(a + 1	,		4_00	):
         for c in range(b + 1	,		5_00	):
            if (a + b + c) == 10_00 and (a**2) + (b**2) == (c**2):
               return a * b * c

   return -1




def 							_SCREAMING_SNAKE_CASE	(					)     ->			int:







   """simple docstring"""

   for a in range(3_00	):
      for b in range(4_00	):
         __snake_case					:   Optional[Any]  				=			10_00 - a - b
         if a < b < c and (a**2) + (b**2) == (c**2):
            return a * b * c

   return -1




def 							_SCREAMING_SNAKE_CASE	(					)     ->			None:







   """simple docstring"""
   import timeit

   print(
       timeit.timeit('solution()'	,		setup='from __main__ import solution'	,		number=10_00	)	)
   print(
       timeit.timeit(
           'solution_fast()'	,		setup='from __main__ import solution_fast'	,		number=10_00	)	)


if __name__ == "__main__":
      print(f'''{solution() = }''')