


def 							__lowercase     (				__lowerCAmelCase							:       Union[str, Any]      ,					__lowerCAmelCase							:       int     ):
							print('\nThe shortest path matrix using Floyd Warshall algorithm\n'     )
							for i in range(__lowerCAmelCase     ):
														for j in range(__lowerCAmelCase     ):
																					if dist[i][j] != float('inf'     ):
																												print(int(dist[i][j]     )      ,					end='\t'     )
																					else:
																												print('INF'      ,					end='\t'     )
														print()






def 							__lowercase     (				__lowerCAmelCase							:       List[Any]      ,					__lowerCAmelCase							:       int     ):
							a__    =  [[float('inf'     ) for _ in range(__lowerCAmelCase     )] for _ in range(__lowerCAmelCase     )]

							for i in range(__lowerCAmelCase     ):
														for j in range(__lowerCAmelCase     ):
																					a__    =  graph[i][j]

																					# check vertex k against all other vertices (i, j)
							for k in range(__lowerCAmelCase     ):
														# looping through rows of graph array
														for i in range(__lowerCAmelCase     ):
																					# looping through columns of graph array
																					for j in range(__lowerCAmelCase     ):
																												if (
																												    dist[i][k] != float('inf'     )
																												    and dist[k][j] != float('inf'     )
																												    and dist[i][k] + dist[k][j] < dist[i][j]
																												):
																																			a__    =  dist[i][k] + dist[k][j]

							_print_dist(__lowerCAmelCase      ,					__lowerCAmelCase     )
							return dist, v


if __name__ == "__main__":
						snake_case      =   int(input('''Enter number of vertices: '''))
						snake_case      =   int(input('''Enter number of edges: '''))

						snake_case      =   [[float('''inf''') for i in range(v)] for j in range(v)]

						for i in range(v):
												snake_case      =   0.0

												# src and dst are indices that must be within the array size graph[e][v]
												# failure to follow this will result in an error
						for i in range(e):
												print('''\nEdge ''', i + 1)
												snake_case      =   int(input('''Enter source:'''))
												snake_case      =   int(input('''Enter destination:'''))
												snake_case      =   float(input('''Enter weight:'''))
												snake_case      =   weight

						floyd_warshall(graph, v)

						# Example Input
						# Enter number of vertices: 3
						# Enter number of edges: 2

						# # generated graph from vertex and edge inputs
						# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
						# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

						# specify source, destination and weight for edge #1
						# Edge  1
						# Enter source:1
						# Enter destination:2
						# Enter weight:2

						# specify source, destination and weight for edge #2
						# Edge  2
						# Enter source:2
						# Enter destination:1
						# Enter weight:1

						# # Expected Output from the vertice, edge and src, dst, weight inputs!!
						# 0		INF	INF
						# INF	0	2
						# INF	1	0








from math import ceil, sqrt






def 							__lowercase     (				__lowerCAmelCase							:       int = 1_0_0_0_0_0_0     ):
							a__    =  0

							for outer_width in range(3      ,					(limit // 4) + 2     ):
														if outer_width**2 > limit:
																					a__    =  max(ceil(sqrt(outer_width**2 - limit     )     )      ,					1     )
														else:
																					a__    =  1
														if (outer_width - hole_width_lower_bound) % 2:
																					hole_width_lower_bound += 1

														answer += (outer_width - hole_width_lower_bound - 2) // 2 + 1

							return answer


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




