class BPlusTree:

def __init__(self, t):

self.root = None
self.t = t

class Node:
def __init__(self, leaf=False):
self.leaf = leaf
self.keys = []
self.children = []

def is_full(self):
return len(self.keys) == 2 * self.parent.t - 1

class LeafNode(Node):
def __init__(self):
super().__init__(True)
self.next = None

def add_value(self, val):

self.keys.append(val)

def split(self):
new_node = BPlusTree.LeafNode()
mid = len(self.keys) // 2
new_node.keys = self.keys[mid:]
self.keys = self.keys[:mid]
new_node.next = self.next
self.next = new_node
return self.parent.add_child(new_node)

class InternalNode(Node):
def add_child(self, child):
self.children.append(child)
child.parent = self
if self.is_full():
return self.split()
return self

def split(self):
new_node = BPlusTree.InternalNode()
mid = len(self.keys) // 2
new_node.keys = self.keys[mid:]
new_node.children = self.children[mid:]
self.keys = self.keys[:mid]
self.children = self.children[:mid]
new_node.children[0].parent = new_node
return self.parent.add_child(new_node)

def add(self, val):

if self.root is None:
self.root = self.LeafNode()
self.root.keys.append(val)
self.root.parent = self
else:
leaf = self.root.get_leaf()
if leaf.is_full():
leaf.split()
leaf = leaf.get_leaf()
 leaf.add_value(val)

def get_leaf(self):
node = self.root
while not node.leaf:
node = node.children[0]
return node

def search(self, val):

node = self.root
while node is not None:
if val in node.keys:
return True
elif node.leaf:
return False
else:
i = 0
while i < len(node.keys) and val > node.keys[i]:
i += 1
node = node.children[i]
return False

# Example usage

tree = BPlusTree(2)
tree.add(5)
tree.add(8)
tree.add(12)
tree.add(15)
tree.add(17)
tree.add(19)
tree.add(21)
tree.add(24)
print