class GrowableArrayNode:
	def __init__(self, item=None):
		self.item = item
		self.left = None
		self.right = None

	def put(self, item, index):
		if index == 1:
			self.item = item
		elif index % 2 == 0:
			if not self.left:
				self.left = GrowableArrayNode()
			self.left.put(item, index/2)
		else:
			if not self.right:
				self.right = GrowableArrayNode()
			self.right.put(item, index/2)

	def get(self, index):
		if index == 1:
			return self.item

		if index % 2 == 0:
			return self.left.get(index / 2)
		else: return self.right.get(index / 2)

	def traverse(self):
		if self.left:
			for x in self.left.traverse():
				yield x
		yield self
		if self.right:
			for x in self.right.traverse():
				yield x

	def hirem(self,index):
		if index / 2 == 1:
			if index % 2 == 0:
				self.left = None
			else:
				self.right = None
		elif index % 2 == 0:
			self.left.hirem(index / 2)
		else:
			self.right.hirem(index / 2)

class GrowableArray:
	def __init__(self):
		self.root = None

	def get(self,index):
		if self.root == None:
			return None

		return self.root.get(index)

	def put(self,item):
		if self.root == None:
			self.root = GrowableArrayNode()
			self.cur = 0
		self.cur += 1
		self.root.put(item,self.cur)

	def print_items(self):
		for node in self.root.traverse():
			print node.item

	def hirem(self):
		if self.root:
			self.root.hirem(self.cur)
			self.cur -= 1

class exArray():
	key = None
	left = None
	right = None
	def get(self, index):
		if (index == 0):
			print 'index out of bounds'
		elif (index == 1):
			if (self.key == None):
				print 'index out of bounds'
			else:
				return self.key
		elif (index%2 == 0):
			if (self.left):
				return self.left.get(index >> 1)
			else:
				print 'index out of bounds'
		else:
			if (self.right):
				return self.right.get(index >> 1)
			else:
				print 'index out of bounds'
	def put(self, index, key):
		if (index == 0):
			print 'index out of bounds'
		elif (index == 1):
			self.key = key
		elif (index%2 == 0):
			if (not self.left):
				self.left = exArray()
			self.left.put(index >> 1, key)
		else:
			if (not self.right):
				self.right = exArray()
			self.right.put(index >> 1, key)

data Grow a = Empty | Grow { val :: a, l :: Grow a, r:: Grow a }

walk :: (Int -> Grow a -> b) -> Int -> Grow a -> b
walk f i = f (div i 2) . if even i then l else r

modify :: Grow a -> (Int -> Grow a -> Grow a) -> Int -> Grow a -> Grow a
modify d _ _ Empty         = d
modify _ f i g | even i    = g { l = walk f i g }
               | otherwise = g { r = walk f i g }

get :: Int -> Grow a -> Maybe a
get _ Empty = Nothing
get 1 g     = Just $ val g
get i g     = walk get i g

put :: Int -> a -> Grow a -> Grow a
put 1 x Empty = Grow x Empty Empty
put 1 x g     = g { val = x }
put i x g     = modify (error "array out of bounds") (`put` x) i g

hirem :: Int -> Grow a -> Grow a
hirem 1 = const Empty
hirem i = modify Empty hirem i