






"""simple docstring"""





from __future__ import annotations

import queue
class    __lowerCamelCase    :

   def __init__(					self ,				snake_case_      )		->       Dict:
       UpperCamelCase__         =    data
       UpperCamelCase__         =    None
       UpperCamelCase__         =    None







def   lowerCAmelCase_( )					->	TreeNode:
    """simple docstring"""

    print('\n********Press N to stop entering at any point of time********\n'					)
    UpperCamelCase__         =    input('Enter the value of the root node: '					).strip().lower()
    UpperCamelCase__         =    queue.Queue()
    UpperCamelCase__         =    TreeNode(int(SCREAMING_SNAKE_CASE					)					)
    q.put(SCREAMING_SNAKE_CASE					)
    while not q.empty():
        UpperCamelCase__         =    q.get()
        UpperCamelCase__         =    F'Enter the left node of {node_found.data}: '
        UpperCamelCase__         =    input(SCREAMING_SNAKE_CASE					).strip().lower() or 'n'
        if check == "n":
            return tree_node
        UpperCamelCase__         =    TreeNode(int(SCREAMING_SNAKE_CASE					)					)
        UpperCamelCase__         =    left_node
        q.put(SCREAMING_SNAKE_CASE					)
        UpperCamelCase__         =    F'Enter the right node of {node_found.data}: '
        UpperCamelCase__         =    input(SCREAMING_SNAKE_CASE					).strip().lower() or 'n'
        if check == "n":
            return tree_node
        UpperCamelCase__         =    TreeNode(int(SCREAMING_SNAKE_CASE					)					)
        UpperCamelCase__         =    right_node
        q.put(SCREAMING_SNAKE_CASE					)
    raise







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    print(node.data ,	end=','					)
    pre_order(node.left					)
    pre_order(node.right					)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    in_order(node.left					)
    print(node.data ,	end=','					)
    in_order(node.right					)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    post_order(node.left					)
    post_order(node.right					)
    print(node.data ,	end=','					)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    UpperCamelCase__         =    queue.Queue()
    q.put(SCREAMING_SNAKE_CASE					)
    while not q.empty():
        UpperCamelCase__         =    q.get()
        print(node_dequeued.data ,	end=','					)
        if node_dequeued.left:
            q.put(node_dequeued.left					)
        if node_dequeued.right:
            q.put(node_dequeued.right					)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    UpperCamelCase__         =    queue.Queue()
    q.put(SCREAMING_SNAKE_CASE					)
    while not q.empty():
        UpperCamelCase__         =    []
        while not q.empty():
            UpperCamelCase__         =    q.get()
            print(node_dequeued.data ,	end=','					)
            if node_dequeued.left:
                list_.append(node_dequeued.left					)
            if node_dequeued.right:
                list_.append(node_dequeued.right					)
        print()
        for node in list_:
            q.put(SCREAMING_SNAKE_CASE					)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    UpperCamelCase__         =    []
    UpperCamelCase__         =    node
    while n or stack:
        while n:  # start from root node, find its left child
            print(n.data ,	end=','					)
            stack.append(SCREAMING_SNAKE_CASE					)
            UpperCamelCase__         =    n.left
        # end of while means current node doesn't have left child
        UpperCamelCase__         =    stack.pop()
        # start to traverse its right child
        UpperCamelCase__         =    n.right







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    UpperCamelCase__         =    []
    UpperCamelCase__         =    node
    while n or stack:
        while n:
            stack.append(SCREAMING_SNAKE_CASE					)
            UpperCamelCase__         =    n.left
        UpperCamelCase__         =    stack.pop()
        print(n.data ,	end=','					)
        UpperCamelCase__         =    n.right







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	None:
    """simple docstring"""

    if not isinstance(SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					) or not node:
        return
    UpperCamelCase__       ,						UpperCamelCase__         =    [], []
    UpperCamelCase__         =    node
    stacka.append(SCREAMING_SNAKE_CASE					)
    while stacka:  # to find the reversed order of post order, store it in stack2
        UpperCamelCase__         =    stacka.pop()
        if n.left:
            stacka.append(n.left					)
        if n.right:
            stacka.append(n.right					)
        stacka.append(SCREAMING_SNAKE_CASE					)
    while stacka:  # pop up from stack2 will be the post order
        print(stacka.pop().data ,	end=','					)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE = "" ,	SCREAMING_SNAKE_CASE=50 ,	SCREAMING_SNAKE_CASE="*"					)					->	str:
    """simple docstring"""

    if not s:
        return "\n" + width * char
    UpperCamelCase__       ,						UpperCamelCase__         =    divmod(width - len(SCREAMING_SNAKE_CASE					) - 2 ,	2					)
    return F'{left * char} {s} {(left + extra) * char}'


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  print(prompt("""Binary Tree Traversals"""))

  A__					: TreeNode=	build_tree()
  print(prompt("""Pre Order Traversal"""))
  pre_order(node)
  print(prompt() + """\n""")

  print(prompt("""In Order Traversal"""))
  in_order(node)
  print(prompt() + """\n""")

  print(prompt("""Post Order Traversal"""))
  post_order(node)
  print(prompt() + """\n""")

  print(prompt("""Level Order Traversal"""))
  level_order(node)
  print(prompt() + """\n""")

  print(prompt("""Actual Level Order Traversal"""))
  level_order_actual(node)
  print("""*""" * 50 + """\n""")

  print(prompt("""Pre Order Traversal - Iteration Version"""))
  pre_order_iter(node)
  print(prompt() + """\n""")

  print(prompt("""In Order Traversal - Iteration Version"""))
  in_order_iter(node)
  print(prompt() + """\n""")

  print(prompt("""Post Order Traversal - Iteration Version"""))
  post_order_iter(node)
  print(prompt())












"""simple docstring"""





from collections import defaultdict
from math import ceil, sqrt







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE = 1_00_00_00 ,	SCREAMING_SNAKE_CASE = 10					)					->	int:
    """simple docstring"""

    UpperCamelCase__         =    defaultdict(SCREAMING_SNAKE_CASE					)

    for outer_width in range(3 ,	(t_limit // 4) + 2					):
        if outer_width * outer_width > t_limit:
            UpperCamelCase__         =    max(
                ceil(sqrt(outer_width * outer_width - t_limit					)					) ,	1					)
        else:
            UpperCamelCase__         =    1

        hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

        for hole_width in range(SCREAMING_SNAKE_CASE ,	outer_width - 1 ,	2					):
            count[outer_width * outer_width - hole_width * hole_width] += 1

    return sum(1 for n in count.values() if 1 <= n <= 10					)


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




