code: 
  
  from typing import Any, Dict, List, Mapping
  
  import numpy as np
  import torch
  
  from ...utils import is_cython_available, requires_backends
  
  
  if is_cython_available():
  				import pyximport
  
  				pyximport.install(setup_args={'include_dirs': np.get_include()})
  				from . import algos_graphormer  # noqa E402
  
  
  def 					__lowerCAmelCase			(  _A ,_A = 512					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	x.shape[1] if len(x.shape					) > 1 else 1
  							_lowercase				=	1 + np.arange(0 ,feature_num * offset ,_A ,dtype=np.intaa					)
  							_lowercase				=	x + feature_offset
  							return x
  
  
  def 					__lowerCAmelCase			(  _A ,_A=True					):
  
  
  
  							"""simple docstring"""
  
  
  							requires_backends(_A ,["""cython"""]					)
  
  							if keep_features and "edge_attr" in item.keys():  # edge_attr
  														_lowercase				=	np.asarray(item["""edge_attr"""] ,dtype=np.intaa					)
  							else:
  														_lowercase				=	np.ones((len(item["""edge_index"""][0]					), 1) ,dtype=np.intaa					)  # same embedding for all
  
  							if keep_features and "node_feat" in item.keys():  # input_nodes
  														_lowercase				=	np.asarray(item["""node_feat"""] ,dtype=np.intaa					)
  							else:
  														_lowercase				=	np.ones((item["""num_nodes"""], 1) ,dtype=np.intaa					)  # same embedding for all
  
  							_lowercase				=	np.asarray(item["""edge_index"""] ,dtype=np.intaa					)
  
  							_lowercase				=	convert_to_single_emb(_A					) + 1
  							_lowercase				=	item["""num_nodes"""]
  
  							if len(edge_attr.shape					) == 1:
  														_lowercase				=	edge_attr[:, None]
  							_lowercase				=	np.zeros([num_nodes, num_nodes, edge_attr.shape[-1]] ,dtype=np.intaa					)
  							_lowercase				=	convert_to_single_emb(_A					) + 1
  
  							# node adj matrix [num_nodes, num_nodes] bool
  							_lowercase				=	np.zeros([num_nodes, num_nodes] ,dtype=_A					)
  							_lowercase				=	True
  
  							_lowercase				,       _lowercase				=	algos_graphormer.floyd_warshall(_A					)
  							_lowercase				=	np.amax(_A					)
  
  							_lowercase				=	algos_graphormer.gen_edge_input(_A ,_A ,_A					)
  							_lowercase				=	np.zeros([num_nodes + 1, num_nodes + 1] ,dtype=np.single					)  # with graph token
  
  							# combine
  							_lowercase				=	input_nodes + 1  # we shift all indices by one for padding
  							_lowercase				=	attn_bias
  							_lowercase				=	attn_edge_type
  							_lowercase				=	shortest_path_result.astype(np.intaa					) + 1  # we shift all indices by one for padding
  							_lowercase				=	np.sum(_A ,axis=1					).reshape(-1					) + 1  # we shift all indices by one for padding
  							_lowercase				=	item["""in_degree"""]  # for undirected graph
  							_lowercase				=	input_edges + 1  # we shift all indices by one for padding
  							if "labels" not in item:
  														_lowercase				=	item["""y"""]
  
  							return item
  
  
  
  
  
  
  
  class _lowercase					:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							def __init__(    self     ,   UpperCAmelCase=20     ,   UpperCAmelCase=False  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														if not is_cython_available():
  																					raise ImportError("""Graphormer preprocessing needs Cython (pyximport)"""  )
  
  														_lowercase				=	spatial_pos_max
  														_lowercase				=	on_the_fly_processing
  
  
  
  							def __call__(    self     ,   UpperCAmelCase  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														if self.on_the_fly_processing:
  																					_lowercase				=	[preprocess_item(lowerCAmelCase_  ) for i in features]
  
  														if not isinstance(features[0]     ,   lowerCAmelCase_  ):
  																					_lowercase				=	[vars(lowerCAmelCase_  ) for f in features]
  														_lowercase				=	{}
  
  														_lowercase				=	max(len(i["""input_nodes"""]  ) for i in features  )
  														_lowercase				=	len(features[0]["""input_nodes"""][0]  )
  														_lowercase				=	len(features[0]["""attn_edge_type"""][0][0]  )
  														_lowercase				=	max(len(i["""input_edges"""][0][0]  ) for i in features  )
  														_lowercase				=	len(features[0]["""input_edges"""][0][0][0]  )
  														_lowercase				=	len(lowerCAmelCase_  )
  
  														_lowercase				=	torch.zeros(lowerCAmelCase_     ,   max_node_num + 1     ,   max_node_num + 1     ,   dtype=torch.float  )
  														_lowercase				=	torch.zeros(lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   dtype=torch.long  )
  														_lowercase				=	torch.zeros(lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   dtype=torch.long  )
  														_lowercase				=	torch.zeros(lowerCAmelCase_     ,   lowerCAmelCase_     ,   dtype=torch.long  )
  														_lowercase				=	torch.zeros(lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   dtype=torch.long  )
  														_lowercase				=	torch.zeros(
  														    lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   lowerCAmelCase_     ,   dtype=torch.long  )
  
  														for ix, f in enumerate(lowerCAmelCase_  ):
  																					for k in ["attn_bias", "attn_edge_type", "spatial_pos", "in_degree", "input_nodes", "input_edges"]:
  																												_lowercase				=	torch.tensor(f[k]  )
  
  																					if len(f["""attn_bias"""][1:, 1:][f["""spatial_pos"""] >= self.spatial_pos_max]  ) > 0:
  																												_lowercase				=	float("""-inf"""  )
  
  																					_lowercase				=	f["""attn_bias"""]
  																					_lowercase				=	f[
  																					    """attn_edge_type"""
  																					]
  																					_lowercase				=	f["""spatial_pos"""]
  																					_lowercase				=	f["""in_degree"""]
  																					_lowercase				=	f["""input_nodes"""]
  																					_lowercase				=	f["""input_edges"""]
  
  														_lowercase				=	batch["""in_degree"""]
  
  														_lowercase				=	features[0]["""labels"""]
  														if len(lowerCAmelCase_  ) == 1:  # one task
  																					if isinstance(sample[0]     ,   lowerCAmelCase_  ):  # regression
  																												_lowercase				=	torch.from_numpy(np.concatenate([i["""labels"""] for i in features]  )  )
  																					else:  # binary classification
  																												_lowercase				=	torch.from_numpy(np.concatenate([i["""labels"""] for i in features]  )  )
  														else:  # multi task classification, left to float to keep the NaNs
  																					_lowercase				=	torch.from_numpy(np.stack([i["""labels"""] for i in features]     ,   axis=0  )  )
  
  														return batch
  
  
  
style_context: def 					__lowerCAmelCase			(  _A = 998_001					):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	0
  							for i in range(999 ,99 ,-1					):  # 3 digit numbers range from 999 down to 100
  														for j in range(999 ,99 ,-1					):
  																					_lowercase				=	str(i * j					)
  																					if product_string == product_string[::-1] and i * j < n:
  																												_lowercase				=	max(_A ,i * j					)
  							return answer
  
  
  if __name__ == "__main__":
  				print(F'''{solution() = }''')
  
  
  