diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..831e756120355f975488fbb106fdacdfd319f120 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +graph-theory/source/examples/images/2500pxLondon_Underground_Overground.png filter=lfs diff=lfs merge=lfs -text +graph-theory/source/examples/images/traffic_bi_directional.gif filter=lfs diff=lfs merge=lfs -text diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..2a56e221842331039db1bc3bcc5766368c0033ff --- /dev/null +++ b/Dockerfile @@ -0,0 +1,18 @@ +FROM python:3.10 + +RUN useradd -m -u 1000 user && python -m pip install --upgrade pip +USER user +ENV PATH="/home/user/.local/bin:$PATH" + +WORKDIR /app + +COPY --chown=user ./requirements.txt requirements.txt +RUN pip install --no-cache-dir --upgrade -r requirements.txt + +COPY --chown=user . /app +ENV MCP_TRANSPORT=http +ENV MCP_PORT=7860 + +EXPOSE 7860 + +CMD ["python", "graph-theory/mcp_output/start_mcp.py"] diff --git a/README.md b/README.md index d8937307ff47ab09e4391ee562df6b68bf44690f..67bf41e13e5f28b9023ce303171e772d82936b13 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,32 @@ --- -title: Graph Theory -emoji: 📈 -colorFrom: pink -colorTo: blue +title: Graph-Theory MCP +emoji: 🤖 +colorFrom: blue +colorTo: purple sdk: docker +sdk_version: "4.26.0" +app_file: app.py pinned: false --- -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +# Graph-Theory MCP Service + +Auto-generated MCP service for graph-theory. + +## Usage + +``` +https://None-graph-theory-mcp.hf.space/mcp +``` + +## Connect with Cursor + +```json +{ + "mcpServers": { + "graph-theory": { + "url": "https://None-graph-theory-mcp.hf.space/mcp" + } + } +} +``` diff --git a/app.py b/app.py new file mode 100644 index 0000000000000000000000000000000000000000..1efa21375d6bec91e4eaab956cc859e1538e7fef --- /dev/null +++ b/app.py @@ -0,0 +1,45 @@ +from fastapi import FastAPI +import os +import sys + +mcp_plugin_path = os.path.join(os.path.dirname(__file__), "graph-theory", "mcp_output", "mcp_plugin") +sys.path.insert(0, mcp_plugin_path) + +app = FastAPI( + title="Graph-Theory MCP Service", + description="Auto-generated MCP service for graph-theory", + version="1.0.0" +) + +@app.get("/") +def root(): + return { + "service": "Graph-Theory MCP Service", + "version": "1.0.0", + "status": "running", + "transport": os.environ.get("MCP_TRANSPORT", "http") + } + +@app.get("/health") +def health_check(): + return {"status": "healthy", "service": "graph-theory MCP"} + +@app.get("/tools") +def list_tools(): + try: + from mcp_service import create_app + mcp_app = create_app() + tools = [] + for tool_name, tool_func in mcp_app.tools.items(): + tools.append({ + "name": tool_name, + "description": tool_func.__doc__ or "No description available" + }) + return {"tools": tools} + except Exception as e: + return {"error": f"Failed to load tools: {str(e)}"} + +if __name__ == "__main__": + import uvicorn + port = int(os.environ.get("PORT", 7860)) + uvicorn.run(app, host="0.0.0.0", port=port) diff --git a/graph-theory/mcp_output/README_MCP.md b/graph-theory/mcp_output/README_MCP.md new file mode 100644 index 0000000000000000000000000000000000000000..97b13eb99aef255ad2d16384ecb63cf25db61662 --- /dev/null +++ b/graph-theory/mcp_output/README_MCP.md @@ -0,0 +1,61 @@ +# Graph Theory MCP (Model Context Protocol) Service + +## Project Introduction + +The Graph Theory MCP service is a comprehensive library designed to facilitate graph-related computations and analyses. It provides a wide range of functionalities, including graph traversal, shortest path calculations, flow problems, and visualization tools. This service is ideal for developers working on projects that require complex graph operations and optimizations. + +## Installation Method + +To install the Graph Theory MCP service, ensure you have Python installed and then use the following pip command to install the necessary dependencies: + +- Required: numpy, scipy +- Optional: matplotlib (for visualization) + +```shell +pip install numpy scipy +pip install matplotlib # Optional for visualization +``` + +## Quick Start + +Here's a quick example to get you started with the Graph Theory MCP service: + +```python +from graph.adjacency_matrix import adjacency_matrix +from graph.shortest_path import shortest_path + +# Example graph represented as an adjacency list +graph = { + 'A': {'B': 1, 'C': 4}, + 'B': {'C': 2, 'D': 5}, + 'C': {'D': 1}, + 'D': {} +} + +# Convert to adjacency matrix +matrix = adjacency_matrix(graph) + +# Find the shortest path from A to D +path = shortest_path(graph, 'A', 'D') +print("Shortest path from A to D:", path) +``` + +## Available Tools and Endpoints List + +- **Graph Construction and Manipulation**: Functions like `adjacency_matrix`, `all_pairs_shortest_paths`, and `all_simple_paths` help in constructing and analyzing graphs. +- **Path and Flow Analysis**: Use `shortest_path`, `maximum_flow`, and `minimum_cost_flow_using_successive_shortest_path` for pathfinding and flow optimization. +- **Graph Algorithms**: Implement algorithms such as `breadth_first_search`, `depth_first_search`, and `topological_sort`. +- **Specialized Problems**: Solve complex problems with `assignment_problem`, `traffic_scheduling_problem`, and `transshipment_problem`. +- **Visualization**: Visualize graphs using `plot_2d`, `plot_3d`, and `visualise`. + +## Common Issues and Notes + +- Ensure all required dependencies are installed to avoid import errors. +- For performance optimization, consider the complexity of the graph algorithms being used, especially for large graphs. +- Optional dependencies like `matplotlib` are necessary for visualization features. + +## Reference Links or Documentation + +For more detailed documentation and examples, visit the [Graph Theory GitHub Repository](https://github.com/root-11/graph-theory). + +For further assistance, you can explore the code structure and documentation once the repository is indexed, which typically takes 2-10 minutes. \ No newline at end of file diff --git a/graph-theory/mcp_output/analysis.json b/graph-theory/mcp_output/analysis.json new file mode 100644 index 0000000000000000000000000000000000000000..1653bfd500af4c426f69b298abfc9e2ceed01381 --- /dev/null +++ b/graph-theory/mcp_output/analysis.json @@ -0,0 +1,915 @@ +{ + "summary": { + "repository_url": "https://github.com/root-11/graph-theory", + "summary": "Imported via zip fallback, file count: 62", + "file_tree": { + ".github/workflows/codecov.yml": { + "size": 758 + }, + ".github/workflows/publish.yml": { + "size": 533 + }, + ".github/workflows/python-test.yml": { + "size": 971 + }, + "README.md": { + "size": 21562 + }, + "datasets/readme.md": { + "size": 123 + }, + "examples/__init__.py": { + "size": 0 + }, + "examples/graphs.py": { + "size": 27277 + }, + "examples/readme.md": { + "size": 2079 + }, + "graph/__init__.py": { + "size": 61 + }, + "graph/adjacency_matrix.py": { + "size": 1109 + }, + "graph/all_pairs_shortest_path.py": { + "size": 1346 + }, + "graph/all_paths.py": { + "size": 2031 + }, + "graph/all_simple_paths.py": { + "size": 1026 + }, + "graph/assignment_problem.py": { + "size": 8343 + }, + "graph/base.py": { + "size": 17623 + }, + "graph/bfs.py": { + "size": 2255 + }, + "graph/core.py": { + "size": 14015 + }, + "graph/critical_path.py": { + "size": 7014 + }, + "graph/cycle.py": { + "size": 1500 + }, + "graph/dag.py": { + "size": 3984 + }, + "graph/degree_of_separation.py": { + "size": 529 + }, + "graph/dfs.py": { + "size": 3120 + }, + "graph/distance_map.py": { + "size": 2862 + }, + "graph/finite_state_machine.py": { + "size": 2187 + }, + "graph/hash_methods.py": { + "size": 4476 + }, + "graph/max_flow.py": { + "size": 3739 + }, + "graph/max_flow_min_cut.py": { + "size": 1155 + }, + "graph/maximum_flow_min_cut.py": { + "size": 1159 + }, + "graph/min_cost_flow.py": { + "size": 4099 + }, + "graph/minmax.py": { + "size": 453 + }, + "graph/minsum.py": { + "size": 469 + }, + "graph/partite.py": { + "size": 1511 + }, + "graph/random.py": { + "size": 2580 + }, + "graph/shortest_path.py": { + "size": 13708 + }, + "graph/shortest_tree_all_pairs.py": { + "size": 1347 + }, + "graph/topological_sort.py": { + "size": 1096 + }, + "graph/traffic_scheduling_problem.py": { + "size": 21370 + }, + "graph/transshipment_problem.py": { + "size": 9102 + }, + "graph/tsp.py": { + "size": 11203 + }, + "graph/version.py": { + "size": 131 + }, + "graph/visuals.py": { + "size": 5430 + }, + "requirements.txt": { + "size": 0 + }, + "setup.py": { + "size": 3104 + }, + "test-requirements.txt": { + "size": 29 + }, + "tests/__init__.py": { + "size": 673 + }, + "tests/test_assignment_problem.py": { + "size": 2876 + }, + "tests/test_basics.py": { + "size": 8869 + }, + "tests/test_facility_location_problem.py": { + "size": 1231 + }, + "tests/test_finite_state_machine.py": { + "size": 2614 + }, + "tests/test_flow_problem.py": { + "size": 7058 + }, + "tests/test_graph.py": { + "size": 354779 + }, + "tests/test_hashgraph.py": { + "size": 2681 + }, + "tests/test_random.py": { + "size": 1665 + }, + "tests/test_search.py": { + "size": 19202 + }, + "tests/test_spatial_graph.py": { + "size": 6926 + }, + "tests/test_topology.py": { + "size": 9945 + }, + "tests/test_traffic_scheduling_problem.py": { + "size": 30238 + }, + "tests/test_transform.py": { + "size": 677 + }, + "tests/test_transshipment_problem.py": { + "size": 4056 + }, + "tests/test_tsp.py": { + "size": 14852 + }, + "tests/test_visuals.py": { + "size": 861 + }, + "tests/test_wtap.py": { + "size": 8086 + } + }, + "processed_by": "zip_fallback", + "success": true + }, + "structure": { + "packages": [ + "source.examples", + "source.graph", + "source.tests" + ] + }, + "dependencies": { + "has_environment_yml": false, + "has_requirements_txt": true, + "pyproject": false, + "setup_cfg": false, + "setup_py": true + }, + "entry_points": { + "imports": [], + "cli": [], + "modules": [] + }, + "llm_analysis": { + "core_modules": [ + { + "package": "examples", + "module": "graphs", + "functions": [ + "grid", + "london_underground" + ], + "classes": [], + "function_signatures": { + "grid": [ + "x", + "y", + "bidirectional" + ], + "london_underground": [] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "adjacency_matrix", + "functions": [ + "adjacency_matrix" + ], + "classes": [], + "function_signatures": { + "adjacency_matrix": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "all_pairs_shortest_path", + "functions": [ + "all_pairs_shortest_paths" + ], + "classes": [], + "function_signatures": { + "all_pairs_shortest_paths": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "all_paths", + "functions": [ + "all_paths" + ], + "classes": [], + "function_signatures": { + "all_paths": [ + "graph", + "start", + "end" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "all_simple_paths", + "functions": [ + "all_simple_paths" + ], + "classes": [], + "function_signatures": { + "all_simple_paths": [ + "graph", + "start", + "end" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "assignment_problem", + "functions": [ + "ap_solver", + "wtap_solver" + ], + "classes": [], + "function_signatures": { + "ap_solver": [ + "graph" + ], + "wtap_solver": [ + "probabilities", + "weapons", + "target_values" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "base", + "functions": [ + "components", + "has_path", + "is_subgraph", + "network_size", + "same_path", + "subgraph" + ], + "classes": [ + "BasicGraph" + ], + "function_signatures": { + "subgraph": [ + "graph", + "nodes" + ], + "is_subgraph": [ + "graph1", + "graph2" + ], + "same_path": [ + "path1", + "path2" + ], + "has_path": [ + "graph", + "path" + ], + "network_size": [ + "graph", + "n1", + "degrees_of_separation" + ], + "components": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "bfs", + "functions": [ + "breadth_first_search", + "breadth_first_walk" + ], + "classes": [], + "function_signatures": { + "breadth_first_search": [ + "graph", + "start", + "end" + ], + "breadth_first_walk": [ + "graph", + "start", + "end", + "reversed_walk" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "core", + "functions": [], + "classes": [ + "Graph", + "Graph3D" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "critical_path", + "functions": [ + "critical_path", + "critical_path_minimize_for_slack" + ], + "classes": [ + "Task" + ], + "function_signatures": { + "critical_path": [ + "graph" + ], + "critical_path_minimize_for_slack": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "cycle", + "functions": [ + "cycle", + "has_cycles" + ], + "classes": [], + "function_signatures": { + "cycle": [ + "graph", + "start", + "mid", + "end" + ], + "has_cycles": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "dag", + "functions": [ + "phase_lines", + "sources" + ], + "classes": [], + "function_signatures": { + "phase_lines": [ + "graph" + ], + "sources": [ + "graph", + "n" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "degree_of_separation", + "functions": [ + "degree_of_separation" + ], + "classes": [], + "function_signatures": { + "degree_of_separation": [ + "graph", + "n1", + "n2" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "dfs", + "functions": [ + "depth_first_search", + "depth_scan" + ], + "classes": [], + "function_signatures": { + "depth_first_search": [ + "graph", + "start", + "end" + ], + "depth_scan": [ + "graph", + "start", + "criteria" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "distance_map", + "functions": [ + "distance_map" + ], + "classes": [], + "function_signatures": { + "distance_map": [ + "graph", + "starts", + "ends", + "reverse" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "finite_state_machine", + "functions": [], + "classes": [ + "FiniteStateMachine" + ], + "function_signatures": {}, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "hash_methods", + "functions": [ + "flow_graph_hash", + "graph_hash", + "merkle_tree" + ], + "classes": [], + "function_signatures": { + "graph_hash": [ + "graph" + ], + "flow_graph_hash": [ + "graph" + ], + "merkle_tree": [ + "data_blocks" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "max_flow", + "functions": [ + "maximum_flow" + ], + "classes": [], + "function_signatures": { + "maximum_flow": [ + "graph", + "start", + "end" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "max_flow_min_cut", + "functions": [ + "maximum_flow_min_cut" + ], + "classes": [], + "function_signatures": { + "maximum_flow_min_cut": [ + "graph", + "start", + "end" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "maximum_flow_min_cut", + "functions": [ + "maximum_flow_min_cut" + ], + "classes": [], + "function_signatures": { + "maximum_flow_min_cut": [ + "graph", + "start", + "end" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "min_cost_flow", + "functions": [ + "minimum_cost_flow_using_successive_shortest_path" + ], + "classes": [], + "function_signatures": { + "minimum_cost_flow_using_successive_shortest_path": [ + "costs", + "inventory", + "capacity" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "minmax", + "functions": [ + "minmax" + ], + "classes": [], + "function_signatures": { + "minmax": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "minsum", + "functions": [ + "minsum" + ], + "classes": [], + "function_signatures": { + "minsum": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "partite", + "functions": [ + "is_partite" + ], + "classes": [], + "function_signatures": { + "is_partite": [ + "graph", + "n" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "random", + "functions": [ + "random_xy_graph", + "xy_distance" + ], + "classes": [], + "function_signatures": { + "xy_distance": [ + "n1", + "n2" + ], + "random_xy_graph": [ + "nodes", + "x_max", + "y_max", + "edges", + "seed" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "shortest_path", + "functions": [ + "distance_from_path", + "shortest_path", + "shortest_path_bidirectional" + ], + "classes": [ + "BiDirectionalSearch", + "SPLength", + "ScanThread", + "ShortestPathCache" + ], + "function_signatures": { + "shortest_path": [ + "graph", + "start", + "end", + "avoids" + ], + "shortest_path_bidirectional": [ + "graph", + "start", + "end", + "avoids" + ], + "distance_from_path": [ + "graph", + "path" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "shortest_tree_all_pairs", + "functions": [ + "shortest_tree_all_pairs" + ], + "classes": [], + "function_signatures": { + "shortest_tree_all_pairs": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "topological_sort", + "functions": [ + "topological_sort" + ], + "classes": [], + "function_signatures": { + "topological_sort": [ + "graph", + "key" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "traffic_scheduling_problem", + "functions": [ + "check_user_input", + "is_ap_solvable", + "jam_solver", + "moves_to_synchronous_moves", + "path_to_moves" + ], + "classes": [ + "JamSolver", + "Load", + "NoSolution", + "State", + "StopCondition", + "Timer", + "UnSolvable" + ], + "function_signatures": { + "check_user_input": [ + "graph", + "loads" + ], + "is_ap_solvable": [ + "assignments" + ], + "path_to_moves": [ + "path" + ], + "moves_to_synchronous_moves": [ + "moves", + "loads" + ], + "jam_solver": [ + "graph", + "loads", + "timeout", + "synchronous_moves", + "return_on_first" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "transshipment_problem", + "functions": [ + "clondike_transshipment_problem", + "find", + "find_perfect_circuit", + "jobs_from_path", + "path_from_schedule", + "schedule", + "schedule_rail_system" + ], + "classes": [ + "Train" + ], + "function_signatures": { + "clondike_transshipment_problem": [], + "schedule_rail_system": [ + "rail_network", + "trains", + "jobs" + ], + "find": [ + "rail_network", + "stops", + "jobs" + ], + "schedule": [ + "graph", + "start", + "jobs" + ], + "jobs_from_path": [ + "path" + ], + "path_from_schedule": [ + "jobs", + "start" + ], + "find_perfect_circuit": [ + "graph", + "start", + "jobs" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "tsp", + "functions": [ + "brute_force", + "tsp_2023", + "tsp_branch_and_bound", + "tsp_greedy" + ], + "classes": [], + "function_signatures": { + "tsp_branch_and_bound": [ + "graph" + ], + "tsp_greedy": [ + "graph" + ], + "brute_force": [ + "graph" + ], + "tsp_2023": [ + "graph" + ] + }, + "description": "Discovered via AST scan" + }, + { + "package": "graph", + "module": "visuals", + "functions": [ + "plot_2d", + "plot_3d", + "visualise" + ], + "classes": [], + "function_signatures": { + "visualise": [ + "func" + ], + "plot_2d": [ + "graph", + "nodes", + "edges" + ], + "plot_3d": [ + "graph", + "nodes", + "edges", + "rotation", + "maintain_aspect_ratio" + ] + }, + "description": "Discovered via AST scan" + } + ], + "cli_commands": [], + "import_strategy": { + "primary": "import", + "fallback": "blackbox", + "confidence": 0.9 + }, + "dependencies": { + "required": [ + "numpy", + "scipy" + ], + "optional": [ + "matplotlib" + ] + }, + "risk_assessment": { + "import_feasibility": 0.8, + "intrusiveness_risk": "low", + "complexity": "medium" + } + }, + "deepwiki_analysis": { + "repo_url": "https://github.com/root-11/graph-theory", + "repo_name": "graph-theory", + "content": "root-11/graph-theory\ngraph-theory\nA simple graph library\nRepository Not Indexed\nThis repository hasn't been indexed yet. Indexing allows you to explore code structure, find documentation, and understand dependencies.\nIndexing typically takes 2-10 minutes to complete after it starts indexing\nOnce indexed, you'll have full access to code exploration and search functionality", + "model": "gpt-4o-2024-08-06", + "source": "selenium", + "success": true + }, + "deepwiki_options": { + "enabled": true, + "model": "gpt-4o-2024-08-06" + }, + "risk": { + "import_feasibility": 0.8, + "intrusiveness_risk": "low", + "complexity": "medium" + } +} \ No newline at end of file diff --git a/graph-theory/mcp_output/diff_report.md b/graph-theory/mcp_output/diff_report.md new file mode 100644 index 0000000000000000000000000000000000000000..c3e4803e70f1f90887f2bffdc92dcd1e60f23e33 --- /dev/null +++ b/graph-theory/mcp_output/diff_report.md @@ -0,0 +1,61 @@ +# Graph-Theory Project Difference Report + +**Repository:** graph-theory +**Project Type:** Python Library +**Date:** February 7, 2026 +**Time:** 17:01:26 +**Intrusiveness:** None +**Workflow Status:** Success +**Test Status:** Failed + +## Project Overview + +The graph-theory project is a Python library designed to provide basic functionalities for graph-related computations and analyses. The library aims to serve as a foundational tool for developers and researchers working with graph data structures and algorithms. + +## Difference Analysis + +### New Files Added + +In this update, a total of 8 new files have been introduced to the repository. These files are expected to enhance the library's capabilities by adding new features or improving existing ones. However, no existing files were modified in this update. + +### Modified Files + +There were no modifications made to existing files in this update. This suggests that the new features or functionalities were implemented without altering the current codebase, maintaining backward compatibility. + +## Technical Analysis + +### New Features + +The addition of 8 new files indicates the introduction of new features or modules. However, without specific details on the content of these files, it is challenging to provide a comprehensive technical analysis. It is recommended to review the commit messages or documentation associated with these files for further insights. + +### Test Status + +The test status for this update is marked as "Failed." This indicates that the new additions or changes have introduced issues that need to be addressed. The failure in tests suggests potential bugs or incompatibilities in the new code. + +## Recommendations and Improvements + +1. **Review New Files:** Conduct a thorough review of the newly added files to understand their purpose and functionality. Ensure that they align with the project's goals and coding standards. + +2. **Debugging and Testing:** Investigate the cause of the test failures. This may involve debugging the new code, identifying the root cause of the issues, and implementing necessary fixes. + +3. **Enhance Test Coverage:** Consider expanding the test suite to cover the new functionalities introduced by the new files. This will help in identifying potential issues early and ensure the reliability of the library. + +4. **Documentation:** Update the project documentation to include information about the new features and how they can be utilized. This will aid users in understanding and effectively using the new functionalities. + +## Deployment Information + +Given the current test failures, it is not recommended to deploy this version of the library. Addressing the test issues should be prioritized before considering deployment to ensure a stable and reliable release. + +## Future Planning + +1. **Stability and Reliability:** Focus on resolving the current test failures to ensure the library's stability and reliability. + +2. **Feature Expansion:** Once the current issues are resolved, consider planning for future feature expansions based on user feedback and project goals. + +3. **Community Engagement:** Engage with the user community to gather feedback and suggestions for future improvements and features. + +4. **Versioning:** Upon successful resolution of the current issues, consider incrementing the library's version to reflect the new additions and improvements. + +## Conclusion + +The recent update to the graph-theory project introduces new functionalities through the addition of 8 new files. However, the current test failures highlight the need for further debugging and testing. By addressing these issues and enhancing documentation and test coverage, the project can continue to evolve and provide valuable tools for graph-related computations. \ No newline at end of file diff --git a/graph-theory/mcp_output/mcp_plugin/__init__.py b/graph-theory/mcp_output/mcp_plugin/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/graph-theory/mcp_output/mcp_plugin/adapter.py b/graph-theory/mcp_output/mcp_plugin/adapter.py new file mode 100644 index 0000000000000000000000000000000000000000..b971d83229de3c13cf3258536c1dc5f8a4c83d70 --- /dev/null +++ b/graph-theory/mcp_output/mcp_plugin/adapter.py @@ -0,0 +1,102 @@ +import os +import sys + +# Path settings +source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source") +sys.path.insert(0, source_path) + +# Import statements +try: + from examples.graphs import Graph + from graph.adjacency_matrix import AdjacencyMatrix + from graph.all_pairs_shortest_path import AllPairsShortestPath + from graph.assignment_problem import AssignmentProblem + from graph.base import BaseGraph + from graph.bfs import BFS + from graph.core import CoreGraph + from graph.critical_path import CriticalPath + from graph.cycle import CycleDetection + from graph.dag import DAG + from graph.degree_of_separation import DegreeOfSeparation + from graph.dfs import DFS + from graph.distance_map import DistanceMap + from graph.finite_state_machine import FiniteStateMachine + from graph.hash_methods import HashMethods + from graph.max_flow import MaxFlow + from graph.max_flow_min_cut import MaxFlowMinCut + from graph.maximum_flow_min_cut import MaximumFlowMinCut + from graph.min_cost_flow import MinCostFlow + from graph.minmax import MinMax + from graph.minsum import MinSum + from graph.partite import PartiteGraph + from graph.random import RandomGraph + from graph.shortest_path import ShortestPath + from graph.shortest_tree_all_pairs import ShortestTreeAllPairs + from graph.topological_sort import TopologicalSort + from graph.traffic_scheduling_problem import TrafficSchedulingProblem + from graph.transshipment_problem import TransshipmentProblem + from graph.tsp import TSP + from graph.visuals import GraphVisuals +except ImportError as e: + print(f"Import failed: {e}. Ensure all modules are available in the source directory.") + +# Adapter class +class Adapter: + """ + Adapter class for the MCP plugin, providing access to various graph-related functionalities. + """ + + def __init__(self): + self.mode = "import" + + # Example method for a class + def create_graph_instance(self): + """ + Create an instance of the Graph class. + + Returns: + dict: A dictionary containing the status and the Graph instance. + """ + try: + graph_instance = Graph() + return {"status": "success", "instance": graph_instance} + except Exception as e: + return {"status": "error", "message": str(e)} + + # Example method for a function + def call_adjacency_matrix(self, *args, **kwargs): + """ + Call the AdjacencyMatrix function with provided arguments. + + Args: + *args: Positional arguments for the function. + **kwargs: Keyword arguments for the function. + + Returns: + dict: A dictionary containing the status and the result of the function call. + """ + try: + result = AdjacencyMatrix(*args, **kwargs) + return {"status": "success", "result": result} + except Exception as e: + return {"status": "error", "message": str(e)} + + # Additional methods for other classes and functions can be added here following the same pattern + + # Error handling and fallback + def handle_import_failure(self): + """ + Handle import failures gracefully. + + Returns: + dict: A dictionary containing the status and a fallback message. + """ + return {"status": "error", "message": "Module import failed. Please check the source path and module availability."} + +# Example usage +if __name__ == "__main__": + adapter = Adapter() + graph_result = adapter.create_graph_instance() + print(graph_result) + adjacency_result = adapter.call_adjacency_matrix() + print(adjacency_result) \ No newline at end of file diff --git a/graph-theory/mcp_output/mcp_plugin/main.py b/graph-theory/mcp_output/mcp_plugin/main.py new file mode 100644 index 0000000000000000000000000000000000000000..fca6ec384e22f703b287550e94cc00baaaa4c4a7 --- /dev/null +++ b/graph-theory/mcp_output/mcp_plugin/main.py @@ -0,0 +1,13 @@ +""" +MCP Service Auto-Wrapper - Auto-generated +""" +from mcp_service import create_app + +def main(): + """Main entry point""" + app = create_app() + return app + +if __name__ == "__main__": + app = main() + app.run() \ No newline at end of file diff --git a/graph-theory/mcp_output/mcp_plugin/mcp_service.py b/graph-theory/mcp_output/mcp_plugin/mcp_service.py new file mode 100644 index 0000000000000000000000000000000000000000..4d6557c7ea7d02a424a6f6f087e4161a34994ad1 --- /dev/null +++ b/graph-theory/mcp_output/mcp_plugin/mcp_service.py @@ -0,0 +1,26 @@ +import os +import sys + +source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source") +if source_path not in sys.path: + sys.path.insert(0, source_path) + +from fastmcp import FastMCP + +# No imports available + +mcp = FastMCP("unknown_service") + + + @mcp.tool(name="core", description="Default core function") + def core(*args, **kwargs): + return {"success": False, "result": None, "error": "no_import_available"} + + + +def create_app(): + """Create and return FastMCP application instance""" + return mcp + +if __name__ == "__main__": + mcp.run(transport="http", host="0.0.0.0", port=8000) \ No newline at end of file diff --git a/graph-theory/mcp_output/requirements.txt b/graph-theory/mcp_output/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..6c9b423f94d26e6f7cf9f9f0d4ba6301249a7f78 --- /dev/null +++ b/graph-theory/mcp_output/requirements.txt @@ -0,0 +1,6 @@ +fastmcp +fastapi +uvicorn[standard] +pydantic>=2.0.0 +numpy +scipy diff --git a/graph-theory/mcp_output/start_mcp.py b/graph-theory/mcp_output/start_mcp.py new file mode 100644 index 0000000000000000000000000000000000000000..fc7fcbd9646ad53f089fc94af8129043a703325a --- /dev/null +++ b/graph-theory/mcp_output/start_mcp.py @@ -0,0 +1,30 @@ + +""" +MCP Service Startup Entry +""" +import sys +import os + +project_root = os.path.dirname(os.path.abspath(__file__)) +mcp_plugin_dir = os.path.join(project_root, "mcp_plugin") +if mcp_plugin_dir not in sys.path: + sys.path.insert(0, mcp_plugin_dir) + +from mcp_service import create_app + +def main(): + """Start FastMCP service""" + app = create_app() + # Use environment variable to configure port, default 8000 + port = int(os.environ.get("MCP_PORT", "8000")) + + # Choose transport mode based on environment variable + transport = os.environ.get("MCP_TRANSPORT", "stdio") + if transport == "http": + app.run(transport="http", host="0.0.0.0", port=port) + else: + # Default to STDIO mode + app.run() + +if __name__ == "__main__": + main() diff --git a/graph-theory/mcp_output/workflow_summary.json b/graph-theory/mcp_output/workflow_summary.json new file mode 100644 index 0000000000000000000000000000000000000000..2801576b6afb6b4a56b6b67b54fe84c47c726212 --- /dev/null +++ b/graph-theory/mcp_output/workflow_summary.json @@ -0,0 +1,196 @@ +{ + "repository": { + "name": "graph-theory", + "url": "https://github.com/root-11/graph-theory", + "local_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/graph-theory", + "description": "Python library", + "features": "Basic functionality", + "tech_stack": "Python", + "stars": 0, + "forks": 0, + "language": "Python", + "last_updated": "", + "complexity": "medium", + "intrusiveness_risk": "low" + }, + "execution": { + "start_time": 1770454771.3532846, + "end_time": 1770454831.8100812, + "duration": 60.4567985534668, + "status": "success", + "workflow_status": "success", + "nodes_executed": [ + "download", + "analysis", + "env", + "generate", + "run", + "review", + "finalize" + ], + "total_files_processed": 3, + "environment_type": "unknown", + "llm_calls": 0, + "deepwiki_calls": 0 + }, + "tests": { + "original_project": { + "passed": false, + "details": {}, + "test_coverage": "100%", + "execution_time": 0, + "test_files": [] + }, + "mcp_plugin": { + "passed": true, + "details": {}, + "service_health": "healthy", + "startup_time": 0, + "transport_mode": "stdio", + "fastmcp_version": "unknown", + "mcp_version": "unknown" + } + }, + "analysis": { + "structure": { + "packages": [ + "source.examples", + "source.graph", + "source.tests" + ] + }, + "dependencies": { + "has_environment_yml": false, + "has_requirements_txt": true, + "pyproject": false, + "setup_cfg": false, + "setup_py": true + }, + "entry_points": { + "imports": [], + "cli": [], + "modules": [] + }, + "risk_assessment": { + "import_feasibility": 0.8, + "intrusiveness_risk": "low", + "complexity": "medium" + }, + "deepwiki_analysis": { + "repo_url": "https://github.com/root-11/graph-theory", + "repo_name": "graph-theory", + "content": "root-11/graph-theory\ngraph-theory\nA simple graph library\nRepository Not Indexed\nThis repository hasn't been indexed yet. Indexing allows you to explore code structure, find documentation, and understand dependencies.\nIndexing typically takes 2-10 minutes to complete after it starts indexing\nOnce indexed, you'll have full access to code exploration and search functionality", + "model": "gpt-4o-2024-08-06", + "source": "selenium", + "success": true + }, + "code_complexity": { + "cyclomatic_complexity": "medium", + "cognitive_complexity": "medium", + "maintainability_index": 75 + }, + "security_analysis": { + "vulnerabilities_found": 0, + "security_score": 85, + "recommendations": [] + } + }, + "plugin_generation": { + "files_created": [ + "mcp_output/start_mcp.py", + "mcp_output/mcp_plugin/__init__.py", + "mcp_output/mcp_plugin/mcp_service.py", + "mcp_output/mcp_plugin/adapter.py", + "mcp_output/mcp_plugin/main.py", + "mcp_output/requirements.txt", + "mcp_output/README_MCP.md" + ], + "main_entry": "start_mcp.py", + "requirements": [ + "fastmcp>=0.1.0", + "pydantic>=2.0.0" + ], + "readme_path": "/export/zxcpu1/shiweijie/code/ghh/Code2MCP/workspace/graph-theory/mcp_output/README_MCP.md", + "adapter_mode": "import", + "total_lines_of_code": 0, + "generated_files_size": 0, + "tool_endpoints": 0, + "supported_features": [ + "Basic functionality" + ], + "generated_tools": [ + "Basic tools", + "Health check tools", + "Version info tools" + ] + }, + "code_review": {}, + "errors": [], + "warnings": [], + "recommendations": [ + "Improve test coverage by adding more unit tests for uncovered modules", + "optimize large test files like `tests/test_graph.py` to improve maintainability", + "ensure all dependencies are up-to-date and consider adding a `pyproject.toml` for better dependency management", + "enhance documentation in `README.md` to include detailed usage examples and API references", + "refactor large modules such as `graph/base.py` and `graph/traffic_scheduling_problem.py` for better readability and performance", + "implement continuous integration to automate testing and deployment processes", + "consider indexing the repository for better code exploration and search functionality", + "review and optimize the performance of critical functions identified in the analysis", + "ensure consistent coding standards across the project by using linters and formatters", + "evaluate the risk assessment and address any potential issues related to import feasibility and complexity." + ], + "performance_metrics": { + "memory_usage_mb": 0, + "cpu_usage_percent": 0, + "response_time_ms": 0, + "throughput_requests_per_second": 0 + }, + "deployment_info": { + "supported_platforms": [ + "Linux", + "Windows", + "macOS" + ], + "python_versions": [ + "3.8", + "3.9", + "3.10", + "3.11", + "3.12" + ], + "deployment_methods": [ + "Docker", + "pip", + "conda" + ], + "monitoring_support": true, + "logging_configuration": "structured" + }, + "execution_analysis": { + "success_factors": [ + "Successful execution of all workflow nodes", + "No errors or warnings during execution" + ], + "failure_reasons": [], + "overall_assessment": "excellent", + "node_performance": { + "download_time": "Efficient, completed without delay", + "analysis_time": "Completed successfully, no issues reported", + "generation_time": "Efficient, all necessary files generated", + "test_time": "Original project tests failed, but MCP plugin tests passed" + }, + "resource_usage": { + "memory_efficiency": "Memory usage not reported, assumed efficient due to lack of issues", + "cpu_efficiency": "CPU usage not reported, assumed efficient due to lack of issues", + "disk_usage": "Disk usage efficient, no excessive file sizes or unnecessary files" + } + }, + "technical_quality": { + "code_quality_score": 85, + "architecture_score": 80, + "performance_score": 75, + "maintainability_score": 70, + "security_score": 85, + "scalability_score": 80 + } +} \ No newline at end of file diff --git a/graph-theory/source/.coveragerc b/graph-theory/source/.coveragerc new file mode 100644 index 0000000000000000000000000000000000000000..68e11d141c097275990621e1cf9375c107d8e172 --- /dev/null +++ b/graph-theory/source/.coveragerc @@ -0,0 +1,4 @@ +[run] +branch = True +concurrency = multiprocessing +omit = setup.py, package.py, examples.py diff --git a/graph-theory/source/LICENSE b/graph-theory/source/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..c4eb653f274e059b7864197f6a0723019e9de9f2 --- /dev/null +++ b/graph-theory/source/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 root-11 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/graph-theory/source/README.md b/graph-theory/source/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5c95bc8c5efc8e0f46fa1b1dbc99e94b4f11b209 --- /dev/null +++ b/graph-theory/source/README.md @@ -0,0 +1,144 @@ +# graph-theory +![Build status](https://github.com/root-11/graph-theory/actions/workflows/python-test.yml/badge.svg) +[![codecov](https://codecov.io/gh/root-11/graph-theory/branch/master/graph/badge.svg?token=hWbKhIXskp)](https://codecov.io/gh/root-11/graph-theory) +[![Downloads](https://pepy.tech/badge/graph-theory)](https://pepy.tech/project/graph-theory) +[![Downloads](https://pepy.tech/badge/graph-theory/month)](https://pepy.tech/project/graph-theory/month) +[![PyPI version](https://badge.fury.io/py/graph-theory.svg)](https://badge.fury.io/py/graph-theory) + + +A simple graph library...
+*... A bit like networkx, just without the overhead...*
+*... similar to graph-tool, without the Python 2.7 legacy...*
+*... with code that you can explain to your boss...*
+ +Detailed tutorial evolving in the [examples section](https://github.com/root-11/graph-theory/blob/master/examples/readme.md). + +--------------------------- +Install: + + pip install graph-theory + +Upgrade: + + pip install graph-theory --upgrade --no-cache + +Testing: + + pytest tests + +--------------------------- +Import: + + import Graph + g = Graph() + + import Graph3d + g3d = Graph3D() + +--------------------------- + +Modules: + +| module | description | +|:---|:---| +| `from graph import Graph, Graph3D` | Elementary methods (see basic methods below) for Graph and Graph3D.| +| `from graph import ...` | All methods available on Graph (see table below) | +| `from graph.assignment_problem import ...` | solvers for assignment problem, the Weapons-Target Assignment Problem, ... | +| `from graph.hash import ...` | graph hash functions: graph hash, merkle tree, flow graph hash | +| `from graph.random import ...` | graph generators for random, 2D and 3D graphs. | +| `from graph.transshipment_problem import ...` | solvers for the transshipment problem | +| `from graph.traffic_scheduling_problem import ...` | solvers for the traffic jams (and slide puzzle) | +| `from graph.visuals import ...` | methods for creating matplotlib plots | +| `from graph.finite_state_machine import ...` | finite state machine | + + +All module functions are available from Graph and Graph3D (where applicable). + +| Graph | Graph3D | methods | returns | example | +|:---:|:---:|:-------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---| +| + | + | `a in g` | assert if g contains node a | | +| + | + | `g.add_node(n, [obj])` | adds a node (with a pointer to object `obj` if given) || +| + | + | `g.copy()` | returns a shallow copy of `g` || +| + | + | `g.node(node1)` | returns object attached to node 1 || +| + | + | `g.del_node(node1)` | deletes node1 and all it's edges || +| + | + | `g.nodes()` | returns a list of nodes || +| + | + | `len(g.nodes())` | returns the number of nodes || +| + | + | `g.nodes(from_node=1)` | returns nodes with edges from node 1 || +| + | + | `g.nodes(to_node=2)` | returns nodes with edges to node 2 || +| + | + | `g.nodes(in_degree=2)` | returns nodes with 2 incoming edges || +| + | + | `g.nodes(out_degree=2)` | returns nodes with 2 outgoing edges || +| + | + | `g.add_edge(1,2,3)` | adds edge to g for vector `(1,2)` with value `3` || +| + | + | `g.edge(1,2)` | returns value of edge between nodes 1 and 2 || +| + | + | `g.edge(1,2,default=3)` | returns `default=3` if `edge(1,2)` doesn't exist.
similar to `d.get(key, 3)` || +| + | + | `g.del_edge(1,2)` | removes edge between nodes 1 and 2 || +| + | + | `g.edges()` | returns a list of edges || +| + | + | `len(g.edges())` | returns the number of edges || +| + | + | `g.edges(path=[path])` | returns a list of edges (along a path if given). || +| + | + | `same_path(p1,p2)` | compares two paths to determine if they contain same sequences
ex.: `[1,2,3] == [2,3,1]` || +| + | + | `g.edges(from_node=1)` | returns edges outgoing from node 1 || +| + | + | `g.edges(to_node=2)` | returns edges incoming to node 2 || +| + | + | `g.from_dict(d)` | updates the graph from a dictionary || +| + | + | `g.to_dict()` | returns the graph as a dictionary || +| + | + | `g.from_list(L)` | updates the graph from a list || +| + | + | `g.to_list()` | return the graph as a list of edges || +| + | + | `g.shortest_path(start,end [, memoize, avoids])` | returns the distance and path for path with smallest edge sum
If `memoize=True`, sub results are cached for faster access if repeated calls.
If `avoids=set()`, then these nodes are not a part of the path. || +| + | + | `g.shortest_path_bidirectional(start,end)` | returns distance and path for the path with smallest edge sum using bidrectional search. || +| + | + | `g.is_connected(start,end)` | determines if there is a path from start to end || +| + | + | `g.breadth_first_search(start,end)` | returns the number of edges and path with fewest edges || +| + | + | `g.breadth_first_walk(start,end)` | returns a generator for a BFS walk || +| + | + | `g.degree_of_separation(n1,n2)` | returns the distance between two nodes using BFS || +| + | + | `g.distance_map(starts,ends, reverse)` | returns a dictionary with the distance from any start to any end (or reverse) || +| + | + | `g.network_size(n1, degree_of_separation)` | returns the nodes within the range given by `degree_of_separation` || +| + | + | `g.topological_sort(key)` | returns a generator that yields node in order from a non-cyclic graph. || +| + | + | `g.critical_path()` | returns the distance of the critical path and a list of Tasks. | [Example](examples/solving%20search%20problems.ipynb) | +| + | + | `g.critical_path_minimize_for_slack()` | returns graph with artificial dependencies that minimises slack. | [Example](examples/solving%20search%20problems.ipynb)| +| + | + | `g.phase_lines()` | returns a dictionary with the phase_lines for a non-cyclic graph. || +| + | + | `g.sources(n)` | returns the source_tree of node `n` || +| + | + | `g.depth_first_search(start,end)` | returns path using DFS and backtracking || +| + | + | `g.depth_scan(start, criteria)` | returns set of nodes where criteria is True || +| + | + | `g.distance_from_path(path)` | returns the distance for path. || +| + | + | `g.maximum_flow(source,sink)` | finds the maximum flow between a source and a sink || +| + | + | `g.maximum_flow_min_cut(source,sink)` | finds the maximum flow minimum cut between a source and a sink || +| + | + | `g.minimum_cost_flow(inventory, capacity)` | finds the total cost and flows of the capacitated minimum cost flow. || +| + | + | `g.solve_tsp()` | solves the traveling salesman problem for the graph.
Available methods: 'greedy' (default) and 'bnb || +| + | + | `g.subgraph_from_nodes(nodes)` | returns the subgraph of `g` involving `nodes` || +| + | + | `g.is_subgraph(g2)` | determines if graph `g2` is a subgraph in g || +| + | + | `g.is_partite(n)` | determines if graph is n-partite || +| + | + | `g.has_cycles()` | determines if there are any cycles in the graph || +| + | + | `g.components()` | returns set of nodes in each component in `g` || +| + | + | `g.same_path(p1,p2)` | compares two paths, returns True if they're the same || +| + | + | `g.adjacency_matrix()` | returns the adjacency matrix for the graph || +| + | + | `g.all_pairs_shortest_paths()` | finds the shortest path between all nodes || +| + | + | `g.minsum()` | finds the node(s) with shortest total distance to all other nodes || +| + | + | `g.minmax()` | finds the node(s) with shortest maximum distance to all other nodes || +| + | + | `g.shortest_tree_all_pairs()` | finds the shortest tree for all pairs || +| + | + | `g.has_path(p)` | asserts whether a path `p` exists in g || +| + | + | `g.all_simple_paths(start,end)` | finds all simple paths between 2 nodes || +| + | + | `g.all_paths(start,end)` | finds all combinations of paths between 2 nodes || +| - | + | `g3d.distance(n1,n2)` | returns the spatial distance between `n1` and `n2` || +| - | + | `g3d.n_nearest_neighbour(n1, [n])` | returns the `n` nearest neighbours to node `n1` || +| - | + | `g3d.plot()` | returns matplotlib plot of the graph. || + + +## FAQ + +| want to... | doesn't work... | do instead... | ...but why? | +|:---|:---|:---|:---| +| have multiple edges between two nodes | `Graph(from_list=[(1,2,3), (1,2,4)]` | Add dummy nodes
`[(1,a,3), (a,2,0),`
` (1,b,4),(b,2,0)]` | Explicit is better than implicit. | +| multiple values on an edge | `g.add_edge(1,2,{'a':3, 'b':4})` | Have two graphs
`g_a.add_edge(1,2,3)`
`g_b.add_edge(1,2,4)` | Most graph algorithms don't work with multiple values | +|do repeated calls to shortest path|`g.shortest_path(a,b)` is slow|Use `g.shortest_path(a,b,memoize=True)` instead|memoize uses bidirectional search and caches sub-results along the shortest path for future retrievals| + +## Credits: + +- Arturo Soucase for packaging and testing. +- Peter Norvig for inspiration on TSP from [pytudes](https://github.com/norvig/pytudes/blob/master/ipynb/TSP.ipynb). +- Harry Darby for the mountain river map. +- Kyle Downey for depth_scan algorithm. +- Ross Blandford for munich firebrigade centre -, traffic jam - and slide puzzle - test cases. +- Avi Kelman for type-tolerant search, and a number of micro optimizations. +- Joshua Crestone for all simple paths test. +- CodeMartyLikeYou for detecting a bug in `@memoize` +- Tom Carroll for detecting the bug in del_edge and inspiration for topological sort. +- Sappique for discovering bugs in `__eq__`, `copy` and `has_cycles`. +- joshinils for discovering bug where `graph.edges(from_node=0)` was interpreted as `False`. + diff --git a/graph-theory/source/__init__.py b/graph-theory/source/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e388698f70617f7b3d8d93877977311421f16d5b --- /dev/null +++ b/graph-theory/source/__init__.py @@ -0,0 +1,4 @@ +# -*- coding: utf-8 -*- +""" +graph-theory Project Package Initialization File +""" diff --git a/graph-theory/source/datasets/readme.md b/graph-theory/source/datasets/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..c4c36b5a1a5f89de444f608ec829e4cd409f06b8 --- /dev/null +++ b/graph-theory/source/datasets/readme.md @@ -0,0 +1,3 @@ +# README +This folder is listed in .gitignore so that developers can have confidential datasets withouth checking them in. + diff --git a/graph-theory/source/examples/__init__.py b/graph-theory/source/examples/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/graph-theory/source/examples/basic graph theory.ipynb b/graph-theory/source/examples/basic graph theory.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8c6031dcfbeb796980b04b2643ba93a10fd8073d --- /dev/null +++ b/graph-theory/source/examples/basic graph theory.ipynb @@ -0,0 +1,941 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# Introduction to Graph-theory\n", + "\n", + "[Graph-theory](https://en.wikipedia.org/wiki/Graph_theory) is the study of graphs,\n", + "which are mathematical structures used to model pairwise relations between objects.\n", + "\n", + "Graphs are among the most ubiquitous models of both natural and human-made structures.\n", + "They can model many types of relations and process dynamics in physical, biological\n", + "and social systems. In computer science, they can represent networks of communication,\n", + "data organization, computational devices, the flow of computation, etc.\n", + "Graphs are one of the principal objects of study in\n", + "[discrete mathematics](https://en.wikipedia.org/wiki/Discrete_mathematics).\n", + "\n", + "![6 nodes](images/6nodes.png)\n", + "\n", + "| alias | name used in
Graph-theory | description | syntax |\n", + "|---|:---:|---|---|\n", + "|node, vertice, point| **node** | an intersection of edges | `g.add_node('x')` |\n", + "| edge, line, link| **edge** | the line that connects intersections | `g.add_edge('a','b')`|\n", + "| the weight, cost or value of an edge | **value** | numeric value of an edge | `g.add_edge('a','b',value=4)`|\n", + "|in-degree | **in_degree**| the number of incoming edges | `g.in_degree('a')` |\n", + "|out-degree| **out_degree**| the number of outgoing edges| `g.out_degree('b')` |\n", + "|path| **path**| an ordered collection of nodes | (a list of nodes) |\n", + "|distance, length, costs| **---** | the sum of values of a set of edges | (number) |\n", + "| subgraph | **subgraph**| the nodes and edges of *g'* exists in *g* ||\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To add nodes the syntax is simple" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph(1 nodes, 0 edges)\n" + ] + } + ], + "source": [ + "from graph import Graph\n", + "g = Graph()\n", + "g.add_node('C')\n", + "print(g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To associate the node with an object, you can use the `obj` keyword like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "g.add_node('C', obj={'monty':'python'})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This save you from managing the objects externally and permits algorithms to use the object directly.\n", + "\n", + "To retrieve the object use:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'monty': 'python'}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.node('C')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And to delete the node use:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "g.del_node('C')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To add edges the syntax is equally simple:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph(2 nodes, 1 edges)\n" + ] + } + ], + "source": [ + "from graph import Graph\n", + "g = Graph()\n", + "g.add_edge('A', 'B', value=4)\n", + "print(g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get all edges use:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('A', 'B', 4)]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.edges()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Or to view a specific edge `value`, use:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.edge('A', 'B')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As you see, `g.edges()` returns a list of immutable tuples with `(from, to, value)`. \n", + "\n", + "Note that it isn't necessary to add the nodes first. When you use `g.add_edge(...)` the library will detect that the nodes haven't been created and add them quietly." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "If you need to update the value on the edge just use `g.add_edge('A','B', value=10)` again.\n", + "The edge works like a dictionary, where the pair of node `'A'` and `'B'` is the key where the `10` is the value.\n", + "\n", + "In some cases it is not required for the graph to be directed. Mathematicians call this undirected.\n", + "In Python a principal philosophy is that *explicit is better than implicit*, so in graph-theory *undirected* is interpreted as bidirectional. To make this explicit when adding edges, either add an edge for both directions, or use the keyword `bidirectional` which is a helper for doing these to step in one step:\n", + "\n", + "|this... | ...is the same as this|\n", + "|---|---|\n", + "|`g.add_edge('A','B')`
`g.add_edge('B','A')`|`g.add_edge('A','B', bidirectional=True)`|\n", + "\n", + "In other cases multiple edges between nodes are required. Graph-theory allows this using\n", + "dummy nodes. Here's an example:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The graph will store the in- and -out-degree of every node when the edges are added and removed, so the in_degree and out_degree is available immediately e.g. ($O(1)$ [computational complexity](https://wiki.python.org/moin/TimeComplexity)). Here's an example:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.in_degree('A')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.out_degree('A')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, to delete an edge, simply use:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "g.del_edge('A','B')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To replicate the graph in the image in the begging of this section, we will use a helper from the graphs initialization methods `from_list`:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "g = Graph(from_list=[(1,2),(2,3),(3,4),(4,5),(5,6),(5,1),(2,5)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we can't create a bidirectional graph implicitly, we can do so explicitly:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "g.from_list([(end,start,value) for start,end,value in g.edges()])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I chose this example deliberately as it illustrates the ability to update the graph from a list of nodes, even if that list comes from the graph itself. I also wanted to show the idiomatic use of list comprehensions for reading `start`, `end`, `value` from the method `g.edges()`.\n", + "\n", + "The reverse operation `to_list` also exists:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(1, 2, 1),\n", + " (1, 5, 1),\n", + " (2, 3, 1),\n", + " (2, 5, 1),\n", + " (2, 1, 1),\n", + " (3, 4, 1),\n", + " (3, 2, 1),\n", + " (4, 5, 1),\n", + " (4, 3, 1),\n", + " (5, 6, 1),\n", + " (5, 1, 1),\n", + " (5, 2, 1),\n", + " (5, 4, 1),\n", + " (6, 5, 1),\n", + " (1,),\n", + " (2,),\n", + " (3,),\n", + " (4,),\n", + " (5,),\n", + " (6,)]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.to_list()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The method lists all edges first, followed by all nodes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If, you have the need to lookup particular edges or values directly `to_dict` may be more convenient:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: {2: 1, 5: 1},\n", + " 2: {3: 1, 5: 1, 1: 1},\n", + " 3: {4: 1, 2: 1},\n", + " 4: {5: 1, 3: 1},\n", + " 5: {6: 1, 1: 1, 2: 1, 4: 1},\n", + " 6: {5: 1}}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.to_dict()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`to_dict`s inverse operation is `from_dict`, which behaves in the exact same way as `to_list`/`from_list`:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "g2 = Graph(from_dict=g.to_dict())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we created `g2` from `g`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{1: {2: 1, 5: 1},\n", + " 2: {3: 1, 5: 1, 1: 1},\n", + " 5: {6: 1, 1: 1, 2: 1, 4: 1},\n", + " 3: {4: 1, 2: 1},\n", + " 4: {5: 1, 3: 1},\n", + " 6: {5: 1}}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g2.to_dict()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This may seem as a long way to copy when the libray already has the method `g.copy()`. The difference between the two methods, though, is that `g2=Graph(from_list(g.to_list()))` does not copy the reference to objects that you may have set using `g.add_node('a', obj='!!!')`. `g.copy()` will copy there reference too." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "from graph import Graph\n", + "\n", + "g = Graph()\n", + "g.add_edge('A', 'B', value=4) # a direct edge\n", + "g.add_edge('A', 'ab', value=2) # dummy edge from A to dummy node ab\n", + "g.add_edge('ab', 'B', value=2) # dummy edge from dummy node ab to B" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Creating these dummy nodes by hand isn't very effective, so if you have a list of edges like in the example below it is good to know that nodes can be any hashable object, e.g. tuples, strings, numbers, ..." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('A', ('A', 'B', 4), 4)\n", + "('A', ('A', 'B', 3), 3)\n", + "('A', ('A', 'B', 2), 2)\n", + "(('A', 'B', 4), 'B', 0)\n", + "(('A', 'B', 3), 'B', 0)\n", + "(('A', 'B', 2), 'B', 0)\n" + ] + } + ], + "source": [ + "L = [('A','B',4), ('A','B',3), ('A','B',2)]\n", + "g = Graph()\n", + "for edge in L:\n", + " start,end,value = edge # using the edge tuple as dummy node.\n", + " g.add_edge(start, edge, value) # adding the value on the way to the dummy node.\n", + " g.add_edge(edge, end, 0) # adding zero as the value has already been added.\n", + "\n", + "for edge in g.edges():\n", + " print(edge)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "The benefit of doing this is that most algorithms are simpler to implement (and understand!) when dummy nodes are explicit. As an outset you will always know your list of \"real\" nodes and can hence exclude dummy nodes when reading through the list of nodes. It would for example be silly to search for a dummy node when looking for the shortest path between two \"real\" nodes, as it is a pragmatic assumption that the algorithm will only have to search for the shortest path between two meaningful points." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Inspecting the source code\n", + "\n", + "Since we are at this, you can count on all algorithms being available directly on the `Graph` class,\n", + "so that, for example the shortest path algorithm is available as:\n", + "\n", + "```\n", + "g.shortest_path('A','B')\n", + "```\n", + "\n", + "All the documentation is also available using the built-in help menu:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function shortest_path in module graph:\n", + "\n", + "shortest_path(self, start, end, memoize=False, avoids=None)\n", + " :param start: start node\n", + " :param end: end node\n", + " :param memoize: boolean (stores paths in a cache for faster repeated lookup)\n", + " :param avoids: optional. A frozen set of nodes that cannot be on the path.\n", + " :return: distance, path as list\n", + "\n" + ] + } + ], + "source": [ + "help(Graph.shortest_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If you want a more detail description of what is going on, it is often helpful to directly to the specific function." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import inspect" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " def shortest_path(self, start, end, memoize=False, avoids=None):\n", + " \"\"\"\n", + " :param start: start node\n", + " :param end: end node\n", + " :param memoize: boolean (stores paths in a cache for faster repeated lookup)\n", + " :param avoids: optional. A frozen set of nodes that cannot be on the path.\n", + " :return: distance, path as list\n", + " \"\"\"\n", + " if not memoize:\n", + " return shortest_path(graph=self, start=start, end=end, avoids=avoids)\n", + "\n", + " if self._cache is None:\n", + " self._cache = ShortestPathCache(graph=self)\n", + " return self._cache.shortest_path(start, end, avoids=avoids)\n", + "\n" + ] + } + ], + "source": [ + "print(inspect.getsource(Graph.shortest_path))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here you see that Graph wraps the function `shortest_path` and, should you choose to use the keyword `memoize=True` that it uses the class `ShortestPathCache`.\n", + "\n", + "These can be inspected again in the same way:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "def shortest_path(graph, start, end, avoids=None):\n", + " \"\"\" single source shortest path algorithm.\n", + " :param graph: class Graph\n", + " :param start: start node\n", + " :param end: end node\n", + " :param avoids: optional set,frozenset or list of nodes that cannot be a part of the path.\n", + " :return distance, path (as list),\n", + " returns float('inf'), [] if no path exists.\n", + " \"\"\"\n", + " if not isinstance(graph, (BasicGraph, Graph, Graph3D)):\n", + " raise TypeError(f\"Expected BasicGraph, Graph or Graph3D, not {type(graph)}\")\n", + " if start not in graph:\n", + " raise ValueError(f\"{start} not in graph\")\n", + " if end not in graph:\n", + " raise ValueError(f\"{end} not in graph\")\n", + " if avoids is None:\n", + " visited = set()\n", + " elif not isinstance(avoids, (frozenset, set, list)):\n", + " raise TypeError(f\"Expect obstacles as set or frozenset, not {type(avoids)}\")\n", + " else:\n", + " visited = set(avoids)\n", + "\n", + " q, minimums = [(0, 0, start, ())], {start: 0}\n", + " i = 1\n", + " while q:\n", + " (cost, _, v1, path) = heappop(q)\n", + " if v1 not in visited:\n", + " visited.add(v1)\n", + " path = (v1, path)\n", + "\n", + " if v1 == end: # exit criteria.\n", + " L = []\n", + " while path:\n", + " v, path = path[0], path[1]\n", + " L.append(v)\n", + " L.reverse()\n", + " return cost, L\n", + "\n", + " for _, v2, dist in graph.edges(from_node=v1):\n", + " if v2 in visited:\n", + " continue\n", + " prev = minimums.get(v2, None)\n", + " next_node = cost + dist\n", + " if prev is None or next_node < prev:\n", + " minimums[v2] = next_node\n", + " heappush(q, (next_node, i, v2, path))\n", + " i += 1\n", + " return float(\"inf\"), []\n", + "\n" + ] + } + ], + "source": [ + "from graph import shortest_path # getting the function behind Graph.shortest_path\n", + "print(inspect.getsource(shortest_path)) # viewing the code" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code is very well annotated, so if the code doesn't explain itself, feel free to ask for a more elaborate example on the [github repo](https://github.com/root-11/graph-theory/issues).\n", + "\n", + "Graph-theory tries to be transparent about everything it does. As the readme on the frontpage says: \n", + "\n", + "> with code you can explain to your boss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Graphs ready for usage" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To ease the learning curve, I've added a collection of graphs that are ready for import.\n", + "Here's one that should be familiar to most Europeans:\n", + "\n", + "![london underground from https://upload.wikimedia.org/wikipedia/commons/thumb/e/e1/London_Underground_Overground_DLR_Crossrail_map_zone.svg/2500px-London_Underground_Overground_DLR_Crossrail_map_zone.svg.png](images/2500pxLondon_Underground_Overground.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from graphs import london_underground" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Graph(302 nodes, 698 edges)\n" + ] + } + ], + "source": [ + "g = london_underground()\n", + "print(g)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each node in the graph is the latitude, longitude and station name" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(51.5226, -0.1571, 'Baker Street')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.node(11)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(51.5225, -0.1631, 'Marylebone')\n", + "(51.5234, -0.1466, \"Regent's Park\")\n", + "(51.5203, -0.17, 'Edgware Road (C)')\n", + "(51.5238, -0.1439, 'Great Portland Street')\n", + "(51.5142, -0.1494, 'Bond Street')\n", + "(51.5347, -0.174, \"St. John's Wood\")\n", + "(51.5472, -0.1803, 'Finchley Road')\n" + ] + } + ], + "source": [ + "for station_nr in g.nodes(to_node=11):\n", + " print(g.node(station_nr))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's make a map" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[(-0.1571, 51.5226), (-0.1631, 51.5225), (-0.1466, 51.5234)]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stations = {station: g.node(station) for station in g.nodes()}\n", + "london_map = Graph()\n", + "for start,end,distance in g.edges():\n", + " lat1,lon1,name1 = stations[start]\n", + " lat2,lon2,name2 = stations[end]\n", + " london_map.add_edge((lon1,lat1), (lon2,lat2))\n", + "\n", + "london_map.nodes()[:3]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "from graph.visuals import plot_2d" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot = plot_2d(london_map)\n", + "plot.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not exactly what you expected? Well there's a reason why the London overground map is famous for its readability in comparison to raw latitudes and longitudes." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/graph-theory/source/examples/comparing graphs.ipynb b/graph-theory/source/examples/comparing graphs.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..956cbd9b30aa743e3fea875a6b9aaffd427aae97 --- /dev/null +++ b/graph-theory/source/examples/comparing graphs.ipynb @@ -0,0 +1,32 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/graph-theory/source/examples/generating and visualising graphs.ipynb b/graph-theory/source/examples/generating and visualising graphs.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..53176d2dda78f881eae5bc07bfef373afcbda7de --- /dev/null +++ b/graph-theory/source/examples/generating and visualising graphs.ipynb @@ -0,0 +1,197 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Visuals\n", + "\n", + "Visualisation is often the only way to verify whether a graph is constructed correct. \n", + "\n", + "Here are a couple of charts below that I use for testing.\n", + "Go and have a look at `tests/test_spatial_graph.py` for some examples.\n", + "\n", + "If that's not what you want right now, there are a couple of pretty charts below..." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from graph import Graph\n", + "from graph.random import random_xy_graph, xy_distance\n", + "from graph.visuals import plot_2d" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A plot of the solution for the traveling salesmans problem for a random_graph" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "g = random_xy_graph(200, x_max=800, y_max=400) # a fully connected graph.\n", + "dist, tour = g.solve_tsp()\n", + "\n", + "# convert the route to a graph.\n", + "g = Graph()\n", + "\n", + "a = tour[0]\n", + "for b in tour[1:]:\n", + " g.add_edge(a, b, xy_distance(a, b))\n", + " a = b\n", + "# add the link back to start.\n", + "b = tour[0]\n", + "g.add_edge(a, b, xy_distance(a, b))\n", + "\n", + "# add a red diamond for the starting point.\n", + "plt = plot_2d(g)\n", + "start = tour[0:1]\n", + "xs, ys = [c[0] for c in start], [c[1] for c in start]\n", + "plt.plot(xs, ys, 'rD', clip_on=False)\n", + "plt.show(block=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A plot of a nice 3D spiral.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os \n", + "os.chdir(\"..\")\n", + "from tests.test_spatial_graph import spiral_graph\n", + "g = spiral_graph()\n", + "plt = g.plot()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A 3D plot of a fishbone diagram in a couple of orientations." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tests.test_spatial_graph import fishbone_graph\n", + "\n", + "g = fishbone_graph()\n", + "plt = g.plot()\n", + "plt.show(block=False)\n", + "plt = g.plot(rotation='yxz')\n", + "plt.show(block=False)\n", + "plt = g.plot(maintain_aspect_ratio=True)\n", + "plt.show(block=False)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "More to come..." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/graph-theory/source/examples/graphs as finite state machines.ipynb b/graph-theory/source/examples/graphs as finite state machines.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..92b81abc1444a4250a117f65387a6067082727b9 --- /dev/null +++ b/graph-theory/source/examples/graphs as finite state machines.ipynb @@ -0,0 +1,848 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Finite State Machines \n", + "\n", + "Overview\n", + "\n", + "1. Fundamentals\n", + "2. Turnstile\n", + "3. Traffic Jam\n", + "4. Sudoku\n", + "\n", + "But first we must be ready:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "[notice] A new release of pip available: 22.2.2 -> 23.1.2\n", + "[notice] To update, run: python.exe -m pip install --upgrade pip\n" + ] + } + ], + "source": [ + "import sys\n", + "assert (sys.version_info.major, sys.version_info.minor) >= (3,7)\n", + "%pip install graph-theory --upgrade --no-cache -q\n", + "from graph import Graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fundamentals\n", + "\n", + "Nomenclature\n", + "\n", + "- A finite state machine is a mathematical model of computation. \n", + "- The model is in exactly one state at any time.\n", + "- The model can change from one state to another using predetermined paths.\n", + "- All possible states is called the \"solution landscape\"\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Turnstile\n", + "\n", + " ![turnstile machine](images/Torniqueterevolution.jpg) ![turnstile](images/turnstile.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from graph.finite_state_machine import FiniteStateMachine\n", + "\n", + "locked, unlocked = 'locked', 'unlocked' # states\n", + "push, coin = 'push', 'coin' # actions\n", + "\n", + "fsm = FiniteStateMachine()\n", + "fsm.add_transition(locked, coin, unlocked) # turnstile is locked. Put in coin to unlock.\n", + "fsm.add_transition(unlocked, push, locked) # turnstile is unlocked. Push the rotor to lock.\n", + "fsm.add_transition(locked, push, locked) # turnstile is locked. Pushing does not unlock.\n", + "fsm.add_transition(unlocked, coin, unlocked) # turnstile is unlocked. Adding more coins does not change state.\n", + "\n", + "fsm.set_initial_state(locked) # set initial state." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'coin', 'push'}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# check options: pay and go\n", + "set(fsm.options())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fsm.current_state == locked" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# now insert coin:\n", + "fsm.next(action=coin)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'coin', 'push'}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# check options:\n", + "set(fsm.options())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fsm.current_state == unlocked" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ok it's unlocked - so we push:\n", + "fsm.next(action=push)\n", + "# and check if it locks behind us:\n", + "fsm.current_state == locked" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Traffic Jam\n", + "\n", + "As finite state machines can be view as a model of *a valid state*, we can use to verify solutions to optimization problems.\n", + "\n", + "In the example below we have a small intersection like, where all the `red`s need to pass all the `blue`s. \n", + "\n", + "The order could matter, but we ignore that for now.\n", + "\n", + "![3-3 traffic jam](images/3-3-cart-traffic-jam_initial.png)\n", + "\n", + "(initial state)\n", + "\n", + "The solution we would like to see looks like this:\n", + "\n", + "![3-3 traffic jan final](images/3-3-cart-traffic-jam.png)\n", + "\n", + "(final state)\n", + "\n", + "And here's the solution that swaps all the blue and red tiles in fewest moves:\n", + "\n", + "![3-3 traffic jam solution](images/traffic_bi_directional.gif)\n", + "\n", + "Q: How did I get to that?\n", + "\n", + "A: 3 steps:\n", + "\n", + "1. Define the system as a FSM using a \"map\" of options.\n", + "2. Set the `initial state`\n", + "3. Search through the solution landscape until the `active state` resembles the `final state`.\n", + "\n", + "\n", + "We will now solve the same problem using a just a tiny subset.\n", + "\n", + "Let's start with the map:\n", + "\n", + "![tjs-map](images/tjs-map.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "g = Graph()\n", + "edges = [(1,2),(2,3),(2,4)]\n", + "for edge in edges:\n", + " g.add_edge(*edge, bidirectional=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next I add the tiles to represent the initial state and the final state:\n", + "\n", + "![tjs with pug](images/tjs-map-loads.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "loads = [\n", + " {'id':'red', 'start': 1, 'ends': 3}, \n", + " {'id': 'blue', 'start': 3, 'ends': 1}\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from graph.traffic_scheduling_problem import jam_solver" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "queue exhausted\n" + ] + } + ], + "source": [ + "solution = jam_solver(g,loads)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'red': (1, 2)},\n", + " {'red': (2, 4), 'blue': (3, 2)},\n", + " {'blue': (2, 1), 'red': (4, 2)},\n", + " {'red': (2, 3)}]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "solution" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "red moves from 1 to 2\n", + "red moves from 2 to 4\n", + "blue moves from 3 to 2\n", + "blue moves from 2 to 1\n", + "red moves from 4 to 2\n", + "red moves from 2 to 3\n" + ] + } + ], + "source": [ + "# in plain english:\n", + "for move in solution:\n", + " for color,(start,end) in move.items():\n", + " print(f\"{color} moves from {start} to {end}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So what kind of `finite state machine` is the traffic jam solver using?\n", + "\n", + "Each state is captured on a graph which represents a `tree of options`. As there are a finite number of options to for changing the finite state machine from it's current state to the next state, we can capture the change as branches our `tree of options`. Every time our \"search\" generates a novel branch, we add that to the tree. The unexplored options then become our \"frontier\" from which we search further.\n", + "\n", + "![tjs](images/3-3-tree-of-states.png)\n", + "\n", + "We can make a deep-copy of our state machine, as the tree above illustrates, but will quickly consume a terrible amount of memory, \n", + "\n", + "To capture each `state` of the `finite state machine` we only need to look at the position of loads. Here is an example:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "state_0 = ((1, 'red'), (2, None), (3, 'blue'), (4, None))\n", + "state_1 = ((1, None), (2, 'red'), (3, 'blue'), (4, None))\n", + "state_2 = ((1, 'red'), (2, 'blue'), (3, None), (4, None))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now put these states into our `tree of options` as a graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "fsm_graph = Graph()\n", + "fsm_graph.add_edge(state_0, state_1) # there is a path from state_0 to state_1\n", + "fsm_graph.add_edge(state_0, state_2) # there is a path from state_0 to state_2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The search now becomes:\n", + "\n", + "1. \"make a change\", \n", + "2. check if it exists in the graph (and add it to the graph if it is novel). \n", + "\n", + "However the state definition contains a lot of `None`s that don't really add much.\n", + "\n", + "Suggestion: Let's just drop all the `None`s that information.\n", + "\n", + "New graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "state_0 = ((1, 'red'), (3, 'blue'))\n", + "state_1 = ((2, 'red'), (3, 'blue'))\n", + "state_2 = ((1, 'red'), (2, 'blue'))\n", + "\n", + "fsm_graph = Graph()\n", + "fsm_graph.add_edge(state_0, state_1)\n", + "fsm_graph.add_edge(state_0, state_2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's nicer to read.\n", + "\n", + "We can now make a solver that identifies a path from the `initial state` to the `final state`, simply by searching along the frontier from the `initial state`:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# we need the \"map\" from earlier:\n", + "the_map = Graph()\n", + "edges = [(1,2),(2,3),(2,4)]\n", + "for edge in edges:\n", + " the_map.add_edge(*edge, bidirectional=True)\n", + "\n", + "# we need the \"frontier\"\n", + "job_queue = [state_0, state_1, state_2] # (you really only need state_0)\n", + "\n", + "# we need a \"final state\"\n", + "final_state = tuple(sorted([(3,'red'), (1,'blue')]))\n", + "\n", + "# we need a search\n", + "while job_queue:\n", + " state = job_queue.pop()\n", + " occupied = {position for position,item in state}\n", + " for position, item in state: # 'red' on position 2.\n", + " for option in the_map.nodes(from_node=position): # positions {1,4}\n", + " if option in occupied:\n", + " continue # skip it.\n", + " \n", + " new_state = tuple(sorted([(option, item)] + [(o,i) for o,i in state if i != item]))\n", + " \n", + " if new_state in fsm_graph:\n", + " continue # we've already seen it.\n", + " \n", + " # we add the new state to be explored.\n", + " fsm_graph.add_edge(state, new_state)\n", + " job_queue.append(new_state)\n", + "\n", + " if new_state == final_state:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the solver has made the tree of options of the finite state diagram we can have a quick look:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[((1, 'red'), (3, 'blue')),\n", + " ((2, 'red'), (3, 'blue')),\n", + " ((1, 'red'), (2, 'blue')),\n", + " ((1, 'red'), (4, 'blue')),\n", + " ((2, 'red'), (4, 'blue')),\n", + " ((3, 'red'), (4, 'blue')),\n", + " ((2, 'blue'), (3, 'red')),\n", + " ((1, 'blue'), (3, 'red')),\n", + " ((1, 'blue'), (2, 'red')),\n", + " ((1, 'blue'), (4, 'red')),\n", + " ((2, 'blue'), (4, 'red')),\n", + " ((3, 'blue'), (4, 'red'))]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fsm_graph.nodes()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To find the fewest moves to resolve the traffic jam, we can just ask the finite state diagram for the shortest path from the `initial state` to the `final state`:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6,\n", + " [((1, 'red'), (3, 'blue')),\n", + " ((1, 'red'), (2, 'blue')),\n", + " ((1, 'red'), (4, 'blue')),\n", + " ((2, 'red'), (4, 'blue')),\n", + " ((3, 'red'), (4, 'blue')),\n", + " ((2, 'blue'), (3, 'red')),\n", + " ((1, 'blue'), (3, 'red'))])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fsm_graph.shortest_path(state_0, final_state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And there you have it! The solution from earlier:\n", + "\n", + "```\n", + "red moves from 1 to 2\n", + "red moves from 2 to 4\n", + "blue moves from 3 to 2\n", + "blue moves from 2 to 1\n", + "red moves from 4 to 2\n", + "red moves from 2 to 3\n", + "```\n", + "\n", + "and the solution above shows, state by state what has changed. \n", + "\n", + "Note that the two valid solutions interchangeable. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sudoku\n", + "\n", + "Solving a sudoku is no different can be done in a similar way, but our search can become a lot more efficient if we introduce the ideas of a wave collapse function.\n", + "\n", + "Q: A what-collapse?\n", + "\n", + "A: A wave collapse function. \n", + "\n", + "Q: ???\n", + "\n", + "A: Imagine you're surfing on a wave from an `initial state` over undefined state (US) space. As the wave rolls over the undefined space (US), it imposes the most probably outcome onto the undefined space. Each insertion causes the options of the neighbouring spaces to collapse from all possible options to very few plausible options. [More about wave collapse functions](https://github.com/mxgmn/WaveFunctionCollapse)\n", + "\n", + "![sudoku](images/sudoku-wave-collapse-1.png)\n", + "\n", + "Inserting for example `2` in the red box would immediately make `2` unavailable in all other boxes in top right corner. That is an example of a collapse of options.\n", + "\n", + "We can describe the \"options\" for each cell as: numbers - (box + row + column), e.g. the `red` cell as:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{2, 7, 9}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{1,2,3,4,5,6,7,8,9} - ({1,3,4,5,6,8} | {3,5} | {3,4,6}) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also describe a whole sudoku's state as a list numbers, with zero as the uncollapsed space:.\n", + "\n", + "The box above hence becomes: \n", + "```\n", + "[8,4,1,\n", + " 0,0,6,\n", + " 5,0,3]\n", + "```\n", + "\n", + "Doing the same for a whole sudoku like this: \n", + "\n", + "![?](images/easy_sudoku.png)\n", + "\n", + "can then be:\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "sudoku = [\n", + " # cell value # cell number\n", + " 0,0,4,0,5,0,0,0,0, # 0, 1, 2, 3, 4, 5, 6, 7, 8,\n", + " 9,0,0,7,3,4,6,0,0, # 9,10,11,12,13,14,15,16,17,\n", + " 0,0,3,0,2,1,0,4,9, # 18,19,20,21,22,23,24,25,26, \n", + " 0,3,5,0,9,0,4,8,0, # 27,28,29,30,31,32,33,34,35,\n", + " 0,9,0,0,0,0,0,3,0, # 36,37,38,39,40,41,42,43,44,\n", + " 0,7,6,0,1,0,9,2,0, # 45,46,47,48,49,50,51,52,53,\n", + " 3,1,0,9,7,0,2,0,0, # 54,55,56,57,58,59,60,61,62,\n", + " 0,0,9,1,8,2,0,0,3, # 63,64,65,66,67,68,69,70,71,\n", + " 0,0,0,0,6,0,1,0,0, # 72,73,74,75,76,77,78,79,80\n", + " # zero = blank.\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To describe the options for a particular cell, we now need some basic math:\n", + "\n", + "We find the set of number that have not been used - just like a minute ago - but we use the \"cell\" based address system." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![field_53 options](images/easy_sudoku3.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from math import floor\n", + "numbers = {1,2,3,4,5,6,7,8,9}\n", + "\n", + "def options(cell,sudoku): \n", + " column = {v for ix, v in enumerate(sudoku) if ix % 9 == cell % 9}\n", + " row = {v for ix, v in enumerate(sudoku) if ix // 9 == cell // 9}\n", + " box = {v for ix, v in enumerate(sudoku) if (ix // (9 * 3) == cell // (9 * 3)) and ((ix % 9) // 3 == (cell % 9) // 3)}\n", + " return numbers - (box | row | column)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{5}" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "options(53, sudoku)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So there's one option for cell number 53, meaning that the solution landscape *must* eventually collapse around this single option. We can now guide our \"search\" by picking the cell's that have least options.\n", + "\n", + "Let's find them:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5, 3, 0, 2, 0, 3, 3, 2, 4]\n", + "[0, 3, 3, 0, 0, 0, 0, 2, 4]\n", + "[4, 3, 0, 2, 0, 0, 3, 0, 0]\n", + "[2, 0, 0, 2, 0, 2, 0, 0, 3]\n", + "[4, 0, 3, 5, 1, 4, 2, 0, 4]\n", + "[2, 0, 0, 4, 0, 3, 0, 0, 1]\n", + "[0, 0, 1, 0, 0, 1, 0, 2, 4]\n", + "[4, 3, 0, 0, 0, 0, 2, 3, 0]\n", + "[5, 4, 3, 3, 0, 2, 0, 3, 4]\n" + ] + } + ], + "source": [ + "degrees_of_freedom = [0 if v!=0 else len(options(ix,sudoku)) for ix,v in enumerate(sudoku)]\n", + "\n", + "for i in range(9):\n", + " print(degrees_of_freedom[i*9:i*9+9])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each of the numbers are the number of options available for each cell.\n", + "\n", + "We can then design our solver to inspect the sudoku as a finite state machine, where the \"current state\" is our partial solution, e.g. a list with 81 integers.\n", + "\n", + "![](images/sudoku_solver1.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2, 6, 4, 8, 5, 9, 3, 1, 7]\n", + "[9, 8, 1, 7, 3, 4, 6, 5, 2]\n", + "[7, 5, 3, 6, 2, 1, 8, 4, 9]\n", + "[1, 3, 5, 2, 9, 7, 4, 8, 6]\n", + "[8, 9, 2, 5, 4, 6, 7, 3, 1]\n", + "[4, 7, 6, 3, 1, 8, 9, 2, 5]\n", + "[3, 1, 8, 9, 7, 5, 2, 6, 4]\n", + "[6, 4, 9, 1, 8, 2, 5, 7, 3]\n", + "[5, 2, 7, 4, 6, 3, 1, 9, 8]\n" + ] + } + ], + "source": [ + "# the sudoku is our initial state.\n", + "initial_state = sudoku[:]\n", + "\n", + "job_queue = [initial_state] # we need the jobqueue in case of ambiguity of choice.\n", + "\n", + "while job_queue:\n", + " state = job_queue.pop(0)\n", + " if not any(i==0 for i in state): # no missing values means that the sudoku is solved.\n", + " break\n", + "\n", + " degrees_of_freedom = [0 if v!=0 else len(options(ix,state)) for ix,v in enumerate(state)]\n", + " least_freedom = min(v for v in degrees_of_freedom if v > 0)\n", + " cell = degrees_of_freedom.index(least_freedom)\n", + "\n", + " for option in options(cell, state): # for each option we add the new state to the queue.\n", + " new_state = state[:]\n", + " new_state[cell] = option\n", + " job_queue.append(new_state)\n", + "\n", + "# we print out the solution\n", + "for i in range(9):\n", + " print(state[i*9:i*9+9])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Conclusions\n", + "\n", + "What did we learn?\n", + "\n", + "Finite State Machines ...\n", + "\n", + "- are mathematical models of states and transitions.\n", + "- can be used as generators for mapping of a solution landscape.\n", + "- can be used to solve any discrete problem." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.5 ('graph310')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + }, + "vscode": { + "interpreter": { + "hash": "26e418a870e8218a0038cc410eecceadac9265fed4dd23580d1f865f336a3180" + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/graph-theory/source/examples/graphs.py b/graph-theory/source/examples/graphs.py new file mode 100644 index 0000000000000000000000000000000000000000..d53e51a5ddd4abd3c66cdaa29b309201bb2682a4 --- /dev/null +++ b/graph-theory/source/examples/graphs.py @@ -0,0 +1,766 @@ +from graph import Graph +from itertools import product + + +def grid(x, y, bidirectional=False): + """ + :param x: number of columns + :param y: number of rows + :param bidirectional: boolean + :return: Graph with grid. + """ + g = Graph() + for i, j in product(range(x), range(y)): + if i % x > 0: # connect west + n1 = i - 1, j + n2 = i, j + g.add_edge(n1, n2, bidirectional=bidirectional) + + if j % y > 0: # connect north + n1 = i, j - 1 + n2 = i, j + g.add_edge(n1, n2, bidirectional=bidirectional) + return g + + +def london_underground(): + """the london underground network""" + london_underground_stations = { # id:(latitude,longitude,station name), + 1: (51.5028, -0.2801, "Acton Town"), + 2: (51.5143, -0.0755, "Aldgate"), + 3: (51.5154, -0.0726, "Aldgate East"), + 4: (51.5107, -0.013, "All Saints"), + 5: (51.5407, -0.2997, "Alperton"), + 7: (51.5322, -0.1058, "Angel"), + 8: (51.5653, -0.1353, "Archway"), + 9: (51.6164, -0.1331, "Arnos Grove"), + 10: (51.5586, -0.1059, "Arsenal"), + 11: (51.5226, -0.1571, "Baker Street"), + 12: (51.4431, -0.1525, "Balham"), + 13: (51.5133, -0.0886, "Bank"), + 14: (51.5204, -0.0979, "Barbican"), + 15: (51.5396, 0.081, "Barking"), + 16: (51.5856, 0.0887, "Barkingside"), + 17: (51.4905, -0.2139, "Barons Court"), + 18: (51.5121, -0.1879, "Bayswater"), + 19: (51.5148, 0.0613, "Beckton"), + 20: (51.5087, 0.055, "Beckton Park"), + 21: (51.5403, 0.127, "Becontree"), + 22: (51.5504, -0.1642, "Belsize Park"), + 24: (51.527, -0.0549, "Bethnal Green"), + 25: (51.512, -0.1031, "Blackfriars"), + 26: (51.5867, -0.0417, "Blackhorse Road"), + 27: (51.5079, -0.0066, "Blackwall"), + 28: (51.5142, -0.1494, "Bond Street"), + 29: (51.5011, -0.0943, "Borough"), + 30: (51.4956, -0.325, "Boston Manor"), + 31: (51.6071, -0.1243, "Bounds Green"), + 32: (51.5273, -0.0208, "Bow Church"), + 33: (51.5269, -0.0247, "Bow Road"), + 34: (51.5766, -0.2136, "Brent Cross"), + 36: (51.5248, -0.0119, "Bromley-By-Bow"), + 38: (51.6028, -0.2641, "Burnt Oak"), + 39: (51.5481, -0.1188, "Caledonian Road"), + 40: (51.5392, -0.1426, "Camden Town"), + 42: (51.5051, -0.0209, "Canary Wharf"), + 44: (51.5113, -0.0904, "Cannon Street"), + 45: (51.6078, -0.2947, "Canons Park"), + 47: (51.5441, -0.1538, "Chalk Farm"), + 48: (51.5185, -0.1111, "Chancery Lane"), + 49: (51.508, -0.1247, "Charing Cross"), + 51: (51.6177, 0.0755, "Chigwell"), + 52: (51.4946, -0.2678, "Chiswick Park"), + 54: (51.4618, -0.1384, "Clapham Common"), + 55: (51.4649, -0.1299, "Clapham North"), + 56: (51.4527, -0.148, "Clapham South"), + 58: (51.5955, -0.2502, "Colindale"), + 59: (51.418, -0.1778, "Colliers Wood"), + 60: (51.5129, -0.1243, "Covent Garden"), + 61: (51.4957, -0.0144, "Crossharbour & London Arena"), + 63: (51.5095, 0.0276, "Custom House"), + 65: (51.5085, 0.064, "Cyprus"), + 66: (51.5443, 0.1655, "Dagenham East"), + 67: (51.5417, 0.1469, "Dagenham Heathway"), + 70: (51.5223, -0.0173, "Devons Road"), + 71: (51.552, -0.2387, "Dollis Hill"), + 72: (51.5152, -0.3017, "Ealing Broadway"), + 73: (51.5101, -0.2882, "Ealing Common"), + 74: (51.492, -0.1973, "Earl's Court"), + 75: (51.5765, -0.397, "Eastcote"), + 76: (51.5168, -0.2474, "East Acton"), + 77: (51.5874, -0.165, "East Finchley"), + 78: (51.5394, 0.0518, "East Ham"), + 79: (51.5093, -0.0021, "East India"), + 80: (51.4586, -0.2112, "East Putney"), + 81: (51.6137, -0.275, "Edgware"), + 82: (51.5199, -0.1679, "Edgware Road (B)"), + 83: (51.5203, -0.17, "Edgware Road (C)"), + 84: (51.4943, -0.1001, "Elephant & Castle"), + 85: (51.5496, 0.1977, "Elm Park"), + 87: (51.5074, -0.1223, "Embankment"), + 89: (51.5282, -0.1337, "Euston"), + 90: (51.526, -0.1359, "Euston Square"), + 91: (51.596, 0.0912, "Fairlop"), + 92: (51.5203, -0.1053, "Farringdon"), + 93: (51.6012, -0.1932, "Finchley Central"), + 94: (51.5472, -0.1803, "Finchley Road"), + 95: (51.5642, -0.1065, "Finsbury Park"), + 96: (51.4804, -0.195, "Fulham Broadway"), + 97: (51.5096, 0.0716, "Gallions Reach"), + 98: (51.5765, 0.0663, "Gants Hill"), + 99: (51.4945, -0.1829, "Gloucester Road"), + 100: (51.5724, -0.1941, "Golders Green"), + 101: (51.5018, -0.2267, "Goldhawk Road"), + 102: (51.5205, -0.1347, "Goodge Street"), + 103: (51.6132, 0.0923, "Grange Hill"), + 104: (51.5238, -0.1439, "Great Portland Street"), + 105: (51.5423, -0.3456, "Greenford"), + 107: (51.5067, -0.1428, "Green Park"), + 108: (51.4915, -0.2754, "Gunnersbury"), + 109: (51.603, 0.0933, "Hainault"), + 110: (51.4936, -0.2251, "Hammersmith"), + 111: (51.5568, -0.178, "Hampstead"), + 112: (51.5302, -0.2933, "Hanger Lane"), + 113: (51.5362, -0.2575, "Harlesden"), + 114: (51.5925, -0.3351, "Harrow & Wealdston"), + 115: (51.5793, -0.3366, "Harrow-on-the-Hill"), + 116: (51.4669, -0.4227, "Hatton Cross"), + 117: (51.4713, -0.4524, "Heathrow Terminals 1, 2 & 3"), + 118: (51.4598, -0.4476, "Heathrow Terminal 4"), + 119: (51.5829, -0.2259, "Hendon Central"), + 120: (51.5033, -0.0215, "Heron Quays"), + 122: (51.5009, -0.1925, "High Street Kensington"), + 123: (51.546, -0.104, "Highbury & Islington"), + 124: (51.5777, -0.1458, "Highgate"), + 125: (51.5538, -0.4499, "Hillingdon"), + 126: (51.5174, -0.12, "Holborn"), + 127: (51.5075, -0.206, "Holland Park"), + 128: (51.5526, -0.1132, "Holloway Road"), + 129: (51.5539, 0.2184, "Hornchurch"), + 130: (51.4713, -0.3665, "Hounslow Central"), + 131: (51.4733, -0.3564, "Hounslow East"), + 132: (51.4734, -0.3855, "Hounslow West"), + 133: (51.5027, -0.1527, "Hyde Park Corner"), + 134: (51.5619, -0.4421, "Ickenham"), + 135: (51.4871, -0.0101, "Island Gardens"), + 136: (51.4884, -0.1053, "Kennington"), + 137: (51.5304, -0.225, "Kensal Green"), + 138: (51.4983, -0.2106, "Kensington (Olympia)"), + 139: (51.5507, -0.1402, "Kentish Town"), + 140: (51.5816, -0.3162, "Kenton"), + 141: (51.477, -0.285, "Kew Gardens"), + 142: (51.5471, -0.2047, "Kilburn"), + 143: (51.5351, -0.1939, "Kilburn Park"), + 144: (51.5846, -0.2786, "Kingsbury"), + 145: (51.5308, -0.1238, "King's Cross St. Pancras"), + 146: (51.5015, -0.1607, "Knightsbridge"), + 147: (51.5172, -0.2107, "Ladbroke Grove"), + 148: (51.4991, -0.1115, "Lambeth North"), + 149: (51.5119, -0.1756, "Lancaster Gate"), + 150: (51.5139, -0.2172, "Latimer Road"), + 151: (51.5113, -0.1281, "Leicester Square"), + 153: (51.5566, -0.0053, "Leyton"), + 154: (51.5683, 0.0083, "Leytonstone"), + 155: (51.5123, -0.0396, "Limehouse"), + 156: (51.5178, -0.0823, "Liverpool Street"), + 157: (51.5052, -0.0864, "London Bridge"), + 159: (51.53, -0.1854, "Maida Vale"), + 160: (51.5712, -0.0958, "Manor House"), + 161: (51.5122, -0.094, "Mansion House"), + 162: (51.5136, -0.1586, "Marble Arch"), + 163: (51.5225, -0.1631, "Marylebone"), + 164: (51.5249, -0.0332, "Mile End"), + 165: (51.6082, -0.2103, "Mill Hill East"), + 166: (51.5108, -0.0863, "Monument"), + 167: (51.5186, -0.0886, "Moorgate"), + 168: (51.6294, -0.432, "Moor Park"), + 169: (51.4022, -0.1948, "Morden"), + 170: (51.5342, -0.1387, "Mornington Crescent"), + 171: (51.4902, -0.0145, "Mudchute"), + 172: (51.5542, -0.2503, "Neasden"), + 173: (51.5756, 0.0899, "Newbury Park"), + 176: (51.4995, -0.3142, "Northfields"), + 177: (51.5483, -0.3687, "Northolt"), + 178: (51.5784, -0.3184, "Northwick Park"), + 179: (51.6111, -0.424, "Northwood"), + 180: (51.6004, -0.4092, "Northwood Hills"), + 181: (51.5237, -0.2597, "North Acton"), + 182: (51.5175, -0.2887, "North Ealing"), + 184: (51.5846, -0.3626, "North Harrow"), + 185: (51.5621, -0.3034, "North Wembley"), + 186: (51.5094, -0.1967, "Notting Hill Gate"), + 188: (51.5263, -0.0873, "Old Street"), + 190: (51.4813, -0.3522, "Osterley"), + 191: (51.4819, -0.113, "Oval"), + 192: (51.515, -0.1415, "Oxford Circus"), + 193: (51.5154, -0.1755, "Paddington"), + 194: (51.527, -0.2841, "Park Royal"), + 195: (51.4753, -0.2011, "Parsons Green"), + 196: (51.5366, -0.3232, "Perivale"), + 197: (51.5098, -0.1342, "Picadilly Circus"), + 198: (51.4893, -0.1334, "Pimlico"), + 199: (51.5926, -0.3805, "Pinner"), + 200: (51.5313, 0.0172, "Plaistow"), + 201: (51.5077, -0.0173, "Poplar"), + 202: (51.572, -0.2954, "Preston Road"), + 203: (51.5093, 0.0336, "Prince Regent"), + 205: (51.4682, -0.2089, "Putney Bridge"), + 206: (51.5341, -0.2047, "Queen's Park"), + 207: (51.5942, -0.2861, "Queensbury"), + 208: (51.5107, -0.1877, "Queensway"), + 209: (51.4942, -0.2359, "Ravenscourt Park"), + 210: (51.5753, -0.3714, "Rayners Lane"), + 211: (51.5763, 0.0454, "Redbridge"), + 212: (51.5234, -0.1466, "Regent's Park"), + 213: (51.4633, -0.3013, "Richmond"), + 215: (51.6171, 0.0439, "Roding Valley"), + 216: (51.501, -0.0525, "Rotherhithe"), + 217: (51.5084, 0.0465, "Royal Albert"), + 218: (51.519, -0.188, "Royal Oak"), + 219: (51.5091, 0.0181, "Royal Victoria"), + 220: (51.5715, -0.4213, "Ruislip"), + 222: (51.5732, -0.4125, "Ruislip Manor"), + 223: (51.523, -0.1244, "Russell Square"), + 224: (51.5822, -0.0749, "Seven Sisters"), + 225: (51.5117, -0.056, "Shadwell"), + 226: (51.5046, -0.2187, "Shepherd's Bush (C)"), + 227: (51.5058, -0.2265, "Shepherd's Bush (H)"), + 228: (51.5227, -0.0708, "Shoreditch"), + 229: (51.4924, -0.1565, "Sloane Square"), + 230: (51.5808, 0.0216, "Snaresbrook"), + 231: (51.4454, -0.2066, "Southfields"), + 234: (51.5011, -0.3072, "South Ealing"), + 235: (51.5646, -0.3521, "South Harrow"), + 236: (51.4941, -0.1738, "South Kensington"), + 237: (51.5701, -0.3081, "South Kenton"), + 238: (51.5007, -0.0191, "South Quay"), + 239: (51.5569, -0.3988, "South Ruislip"), + 240: (51.4154, -0.1919, "South Wimbledon"), + 241: (51.5917, 0.0275, "South Woodford"), + 242: (51.495, -0.2459, "Stamford Brook"), + 243: (51.6194, -0.3028, "Stanmore"), + 244: (51.5221, -0.047, "Stepney Green"), + 245: (51.4723, -0.123, "Stockwell"), + 246: (51.5439, -0.2759, "Stonebridge Park"), + 247: (51.5416, -0.0042, "Stratford"), + 248: (51.4994, -0.1335, "St. James's Park"), + 249: (51.5347, -0.174, "St. John's Wood"), + 250: (51.5146, -0.0973, "St. Paul's"), + 251: (51.5569, -0.3366, "Sudbury Hill"), + 252: (51.5507, -0.3156, "Sudbury Town"), + 253: (51.4933, -0.0478, "Surrey Quays"), + 254: (51.5432, -0.1738, "Swiss Cottage"), + 255: (51.5111, -0.1141, "Temple"), + 257: (51.4361, -0.1598, "Tooting Bec"), + 258: (51.4275, -0.168, "Tooting Broadway"), + 259: (51.5165, -0.131, "Tottenham Court Road"), + 260: (51.5882, -0.0594, "Tottenham Hale"), + 262: (51.5106, -0.0743, "Tower Gateway"), + 263: (51.5098, -0.0766, "Tower Hill"), + 264: (51.5567, -0.1374, "Tufnell Park"), + 265: (51.4951, -0.2547, "Turnham Green"), + 266: (51.5904, -0.1028, "Turnpike Lane"), + 267: (51.559, 0.251, "Upminster"), + 268: (51.5582, 0.2343, "Upminster Bridge"), + 269: (51.5385, 0.1014, "Upney"), + 270: (51.5352, 0.0343, "Upton Park"), + 271: (51.5463, -0.4786, "Uxbridge"), + 272: (51.4861, -0.1253, "Vauxhall"), + 273: (51.4965, -0.1447, "Victoria"), + 274: (51.583, -0.0195, "Walthamstow Central"), + 275: (51.5775, 0.0288, "Wanstead"), + 276: (51.5043, -0.0558, "Wapping"), + 277: (51.5247, -0.1384, "Warren Street"), + 278: (51.5235, -0.1835, "Warwick Avenue"), + 279: (51.5036, -0.1143, "Waterloo"), + 281: (51.5519, -0.2963, "Wembley Central"), + 282: (51.5635, -0.2795, "Wembley Park"), + 283: (51.521, -0.2011, "Westbourne Park"), + 284: (51.5097, -0.0265, "Westferry"), + 285: (51.501, -0.1254, "Westminster"), + 286: (51.518, -0.2809, "West Acton"), + 287: (51.4872, -0.1953, "West Brompton"), + 288: (51.6095, -0.1883, "West Finchley"), + 289: (51.5287, 0.0056, "West Ham"), + 290: (51.5469, -0.1906, "West Hampstead"), + 291: (51.5795, -0.3533, "West Harrow"), + 292: (51.507, -0.0203, "West India Quay"), + 293: (51.4907, -0.2065, "West Kensington"), + 294: (51.5696, -0.4376, "West Ruislip"), + 295: (51.5194, -0.0612, "Whitechapel"), + 296: (51.512, -0.2239, "White City"), + 297: (51.5492, -0.2215, "Willesden Green"), + 298: (51.5326, -0.2478, "Willesden Junction"), + 299: (51.4214, -0.2064, "Wimbledon"), + 300: (51.4343, -0.1992, "Wimbledon Park"), + 301: (51.607, 0.0341, "Woodford"), + 302: (51.6179, -0.1856, "Woodside Park"), + 303: (51.5975, -0.1097, "Wood Green"), + 35: (51.4627, -0.1145, "Brixton"), + 6: (51.6736, -0.607, "Amersham"), + 23: (51.4979, -0.0637, "Bermondsey"), + 50: (51.7052, -0.611, "Chesham"), + 46: (51.6679, -0.561, "Chalfont & Latimer"), + 53: (51.6543, -0.5183, "Chorleywood"), + 214: (51.6404, -0.4733, "Rickmansworth"), + 62: (51.647, -0.4412, "Croxley"), + 280: (51.6573, -0.4177, "Watford"), + 221: (51.5606, -0.4103, "Ruislip Gardens"), + 121: (51.6503, -0.1943, "High Barnet"), + 261: (51.6302, -0.1791, "Totteridge & Whetstone"), + 57: (51.6517, -0.1496, "Cockfosters"), + 187: (51.6476, -0.1318, "Oakwood"), + 232: (51.6322, -0.128, "Southgate"), + 88: (51.6937, 0.1139, "Epping"), + 256: (51.6717, 0.1033, "Theydon Bois"), + 68: (51.6455, 0.0838, "Debden"), + 158: (51.6412, 0.0558, "Loughton"), + 37: (51.6266, 0.0471, "Buckhurst Hill"), + 204: (51.5343, -0.0139, "Pudding Mill Lane"), + 233: (51.501, -0.1052, "Southwark"), + 41: (51.4982, -0.0502, "Canada Water"), + 43: (51.5147, 0.0082, "Canning Town"), + 183: (51.5005, 0.0039, "North Greenwich"), + 64: (51.4827, -0.0096, "Cutty Sark"), + 106: (51.4781, -0.0149, "Greenwich"), + 69: (51.474, -0.0216, "Deptford Bridge"), + 86: (51.4693, -0.0174, "Elverson Road"), + 152: (51.4657, -0.0142, "Lewisham"), + 174: (51.4767, -0.0327, "New Cross"), + 175: (51.4757, -0.0402, "New Cross Gate"), + } + + london_underground_lines = { # line: "name" + 1: "Bakerloo Line", + 3: "Circle Line", + 6: "Hammersmith & City Line", + 7: "Jubilee Line", + 11: "Victoria Line", + 2: "Central Line", + 4: "District Line", + 5: "East London Line", + 8: "Metropolitan Line", + 9: "Northern Line", + 10: "Piccadilly Line", + 12: "Waterloo & City Line", + 13: "Docklands Light Railway", + } + + london_underground_connections = [ # (station1,station2), (line, time) + (11, 163), (1, 1), + (11, 212), (1, 2), + (49, 87), (1, 1), + (49, 197), (1, 2), + (82, 163), (1, 2), + (82, 193), (1, 3), + (84, 148), (1, 3), + (87, 279), (1, 2), + (113, 246), (1, 2), + (113, 298), (1, 2), + (114, 140), (1, 2), + (137, 206), (1, 3), + (137, 298), (1, 3), + (140, 237), (1, 2), + (143, 159), (1, 2), + (143, 206), (1, 2), + (148, 279), (1, 1), + (159, 278), (1, 1), + (185, 237), (1, 2), + (185, 281), (1, 2), + (192, 197), (1, 2), + (192, 212), (1, 2), + (193, 278), (1, 2), + (246, 281), (1, 3), + (13, 156), (2, 2), + (13, 250), (2, 2), + (16, 91), (2, 2), + (16, 173), (2, 2), + (24, 156), (2, 3), + (24, 164), (2, 2), + (28, 162), (2, 1), + (28, 192), (2, 1), + (37, 158), (2, 3), + (37, 301), (2, 3), + (48, 126), (2, 1), + (48, 250), (2, 2), + (51, 103), (2, 2), + (51, 215), (2, 2), + (68, 158), (2, 2), + (68, 256), (2, 3), + (72, 286), (2, 3), + (76, 181), (2, 2), + (76, 296), (2, 3), + (88, 256), (2, 2), + (91, 109), (2, 2), + (98, 173), (2, 3), + (98, 211), (2, 2), + (103, 109), (2, 3), + (105, 177), (2, 2), + (105, 196), (2, 2), + (112, 181), (2, 3), + (112, 196), (2, 2), + (126, 259), (2, 2), + (127, 186), (2, 2), + (127, 226), (2, 1), + (149, 162), (2, 3), + (149, 208), (2, 1), + (153, 154), (2, 3), + (153, 247), (2, 2), + (154, 230), (2, 2), + (154, 275), (2, 2), + (164, 247), (2, 4), + (177, 239), (2, 3), + (181, 286), (2, 2), + (186, 208), (2, 2), + (192, 259), (2, 2), + (211, 275), (2, 2), + (215, 301), (2, 3), + (221, 239), (2, 1), + (221, 294), (2, 3), + (226, 296), (2, 3), + (230, 241), (2, 2), + (241, 301), (2, 2), + (2, 156), (3, 2), + (2, 263), (3, 4), + (11, 83), (3, 3), + (11, 104), (3, 3), + (14, 92), (3, 1), + (14, 167), (3, 2), + (18, 186), (3, 2), + (18, 193), (3, 2), + (25, 161), (3, 1), + (25, 255), (3, 2), + (44, 161), (3, 1), + (44, 166), (3, 2), + (83, 193), (3, 3), + (87, 255), (3, 2), + (87, 285), (3, 2), + (90, 104), (3, 2), + (90, 145), (3, 2), + (92, 145), (3, 4), + (99, 122), (3, 4), + (99, 236), (3, 1), + (122, 186), (3, 3), + (156, 167), (3, 2), + (166, 263), (3, 2), + (229, 236), (3, 2), + (229, 273), (3, 2), + (248, 273), (3, 2), + (248, 285), (3, 2), + (3, 263), (4, 2), + (3, 295), (4, 2), + (15, 78), (4, 4), + (15, 269), (4, 2), + (17, 110), (4, 1), + (17, 293), (4, 2), + (18, 186), (4, 2), + (18, 193), (4, 2), + (21, 67), (4, 3), + (21, 269), (4, 2), + (25, 161), (4, 1), + (25, 255), (4, 2), + (33, 36), (4, 2), + (33, 164), (4, 1), + (36, 289), (4, 2), + (44, 161), (4, 1), + (44, 166), (4, 2), + (52, 1), (4, 2), + (52, 265), (4, 2), + (66, 67), (4, 4), + (66, 85), (4, 3), + (72, 73), (4, 4), + (73, 1), (4, 2), + (74, 99), (4, 3), + (74, 122), (4, 3), + (74, 138), (4, 2), + (74, 287), (4, 2), + (74, 293), (4, 1), + (78, 270), (4, 2), + (80, 205), (4, 2), + (80, 231), (4, 2), + (83, 193), (4, 3), + (85, 129), (4, 2), + (87, 255), (4, 2), + (87, 285), (4, 2), + (96, 195), (4, 2), + (96, 287), (4, 1), + (99, 236), (4, 1), + (108, 141), (4, 3), + (108, 265), (4, 3), + (110, 209), (4, 2), + (122, 186), (4, 3), + (129, 268), (4, 2), + (141, 213), (4, 3), + (164, 244), (4, 2), + (166, 263), (4, 2), + (195, 205), (4, 3), + (200, 270), (4, 2), + (200, 289), (4, 2), + (209, 242), (4, 2), + (229, 236), (4, 2), + (229, 273), (4, 2), + (231, 300), (4, 3), + (242, 265), (4, 1), + (244, 295), (4, 3), + (248, 273), (4, 2), + (248, 285), (4, 2), + (267, 268), (4, 3), + (299, 300), (4, 3), + (4, 70), (13, 2), + (4, 201), (13, 2), + (13, 225), (13, 2), + (19, 97), (13, 2), + (20, 65), (13, 2), + (20, 217), (13, 2), + (27, 79), (13, 2), + (27, 201), (13, 2), + (32, 70), (13, 2), + (32, 204), (13, 2), + (42, 120), (13, 2), + (42, 292), (13, 2), + (43, 79), (13, 2), + (43, 219), (13, 2), + (61, 171), (13, 2), + (61, 238), (13, 2), + (63, 203), (13, 2), + (63, 219), (13, 2), + (64, 106), (13, 2), + (64, 135), (13, 2), + (65, 97), (13, 2), + (69, 86), (13, 2), + (69, 106), (13, 2), + (86, 152), (13, 2), + (120, 238), (13, 2), + (135, 171), (13, 2), + (155, 225), (13, 2), + (155, 284), (13, 2), + (201, 284), (13, 2), + (201, 292), (13, 2), + (203, 217), (13, 2), + (204, 247), (13, 2), + (225, 262), (13, 2), + (284, 292), (13, 2), + (41, 216), (5, 1), + (41, 253), (5, 2), + (174, 253), (5, 4), + (175, 253), (5, 4), + (216, 276), (5, 1), + (225, 276), (5, 1), + (225, 295), (5, 2), + (228, 295), (5, 2), + (3, 156), (6, 4), + (3, 295), (6, 2), + (11, 83), (6, 3), + (11, 104), (6, 3), + (14, 92), (6, 1), + (14, 167), (6, 2), + (15, 78), (6, 4), + (33, 36), (6, 2), + (33, 164), (6, 1), + (36, 289), (6, 2), + (78, 270), (6, 2), + (83, 193), (6, 4), + (90, 104), (6, 2), + (90, 145), (6, 2), + (92, 145), (6, 4), + (101, 110), (6, 2), + (101, 227), (6, 1), + (147, 150), (6, 1), + (147, 283), (6, 2), + (150, 227), (6, 2), + (156, 167), (6, 2), + (164, 244), (6, 2), + (193, 218), (6, 1), + (200, 270), (6, 2), + (200, 289), (6, 2), + (218, 283), (6, 2), + (244, 295), (6, 3), + (11, 28), (7, 2), + (11, 249), (7, 4), + (23, 41), (7, 2), + (23, 157), (7, 3), + (28, 107), (7, 2), + (41, 42), (7, 3), + (42, 183), (7, 3), + (43, 183), (7, 3), + (43, 289), (7, 3), + (45, 207), (7, 2), + (45, 243), (7, 2), + (71, 172), (7, 2), + (71, 297), (7, 2), + (94, 254), (7, 2), + (94, 290), (7, 1), + (107, 285), (7, 3), + (142, 290), (7, 2), + (142, 297), (7, 2), + (144, 207), (7, 2), + (144, 282), (7, 4), + (157, 233), (7, 2), + (172, 282), (7, 4), + (233, 279), (7, 1), + (247, 289), (7, 3), + (249, 254), (7, 1), + (279, 285), (7, 2), + (2, 156), (8, 2), + (6, 46), (8, 4), + (11, 94), (8, 6), + (11, 104), (8, 3), + (14, 92), (8, 1), + (14, 167), (8, 2), + (46, 50), (8, 8), + (46, 53), (8, 4), + (53, 214), (8, 4), + (62, 168), (8, 4), + (62, 280), (8, 3), + (75, 210), (8, 2), + (75, 222), (8, 2), + (90, 104), (8, 2), + (90, 145), (8, 2), + (92, 145), (8, 4), + (94, 282), (8, 7), + (115, 178), (8, 2), + (115, 184), (8, 3), + (115, 291), (8, 2), + (125, 134), (8, 2), + (125, 271), (8, 3), + (134, 220), (8, 3), + (156, 167), (8, 2), + (168, 179), (8, 3), + (168, 214), (8, 4), + (178, 202), (8, 2), + (179, 180), (8, 2), + (180, 199), (8, 2), + (184, 199), (8, 3), + (202, 282), (8, 3), + (210, 291), (8, 3), + (220, 222), (8, 2), + (7, 145), (9, 2), + (7, 188), (9, 3), + (8, 124), (9, 3), + (8, 264), (9, 2), + (12, 56), (9, 2), + (12, 257), (9, 1), + (13, 157), (9, 2), + (13, 167), (9, 3), + (22, 47), (9, 2), + (22, 111), (9, 2), + (29, 84), (9, 1), + (29, 157), (9, 2), + (34, 100), (9, 3), + (34, 119), (9, 2), + (38, 58), (9, 2), + (38, 81), (9, 3), + (40, 47), (9, 2), + (40, 89), (9, 3), + (40, 139), (9, 2), + (40, 170), (9, 1), + (49, 87), (9, 1), + (49, 151), (9, 2), + (54, 55), (9, 2), + (54, 56), (9, 2), + (55, 245), (9, 1), + (58, 119), (9, 3), + (59, 240), (9, 2), + (59, 258), (9, 2), + (77, 93), (9, 4), + (77, 124), (9, 2), + (84, 136), (9, 2), + (87, 279), (9, 2), + (89, 145), (9, 2), + (89, 170), (9, 2), + (89, 277), (9, 1), + (93, 165), (9, 3), + (93, 288), (9, 2), + (100, 111), (9, 4), + (102, 259), (9, 1), + (102, 277), (9, 2), + (121, 261), (9, 3), + (136, 191), (9, 2), + (136, 279), (9, 3), + (139, 264), (9, 2), + (151, 259), (9, 1), + (167, 188), (9, 1), + (169, 240), (9, 4), + (191, 245), (9, 3), + (257, 258), (9, 2), + (261, 302), (9, 3), + (288, 302), (9, 1), + (1, 73), (10, 2), + (1, 234), (10, 4), + (1, 265), (10, 3), + (5, 194), (10, 3), + (5, 252), (10, 2), + (9, 31), (10, 3), + (9, 232), (10, 3), + (10, 95), (10, 2), + (10, 128), (10, 1), + (17, 74), (10, 3), + (17, 110), (10, 2), + (30, 176), (10, 2), + (30, 190), (10, 3), + (31, 303), (10, 2), + (39, 128), (10, 2), + (39, 145), (10, 5), + (57, 187), (10, 4), + (60, 126), (10, 1), + (60, 151), (10, 1), + (73, 182), (10, 3), + (74, 99), (10, 2), + (75, 210), (10, 2), + (75, 222), (10, 2), + (95, 160), (10, 2), + (99, 236), (10, 1), + (107, 133), (10, 2), + (107, 197), (10, 1), + (110, 265), (10, 2), + (116, 117), (10, 3), + (116, 118), (10, 3), + (116, 132), (10, 4), + (117, 118), (10, 5), + (125, 134), (10, 2), + (125, 271), (10, 3), + (126, 223), (10, 2), + (130, 131), (10, 2), + (130, 132), (10, 2), + (131, 190), (10, 2), + (133, 146), (10, 2), + (134, 220), (10, 3), + (145, 223), (10, 2), + (146, 236), (10, 3), + (151, 197), (10, 2), + (160, 266), (10, 3), + (176, 234), (10, 1), + (182, 194), (10, 2), + (187, 232), (10, 3), + (210, 235), (10, 3), + (220, 222), (10, 2), + (235, 251), (10, 2), + (251, 252), (10, 3), + (266, 303), (10, 2), + (26, 260), (11, 2), + (26, 274), (11, 2), + (35, 245), (11, 2), + (89, 145), (11, 2), + (89, 277), (11, 1), + (95, 123), (11, 2), + (95, 224), (11, 4), + (107, 192), (11, 2), + (107, 273), (11, 2), + (123, 145), (11, 4), + (192, 277), (11, 2), + (198, 272), (11, 1), + (198, 273), (11, 3), + (224, 260), (11, 3), + (245, 272), (11, 3), + (13, 279), (12, 4), + ] + + g = Graph() + + for sid, station in london_underground_stations.items(): + g.add_node(sid, obj=station) + for i in range(0,len(london_underground_connections),2): + n1,n2 = london_underground_connections[i] + _,time = london_underground_connections[i+1] + g.add_edge(n1, n2, time, bidirectional=True) + return g diff --git a/graph-theory/source/examples/images/2500pxLondon_Underground_Overground.png b/graph-theory/source/examples/images/2500pxLondon_Underground_Overground.png new file mode 100644 index 0000000000000000000000000000000000000000..9d921c3399e3984498f0ee5c86fa9f080a9aa87c --- /dev/null +++ b/graph-theory/source/examples/images/2500pxLondon_Underground_Overground.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:73a452f9ad42aa7d91b78f7a3c68a8a976dc652909bc967201dbf829e2bc985f +size 1161554 diff --git a/graph-theory/source/examples/images/3-3-cart-traffic-jam.png b/graph-theory/source/examples/images/3-3-cart-traffic-jam.png new file mode 100644 index 0000000000000000000000000000000000000000..1cc17498bdc235245688132fa1c34c87d5ac953d Binary files /dev/null and b/graph-theory/source/examples/images/3-3-cart-traffic-jam.png differ diff --git a/graph-theory/source/examples/images/3-3-cart-traffic-jam_initial.png b/graph-theory/source/examples/images/3-3-cart-traffic-jam_initial.png new file mode 100644 index 0000000000000000000000000000000000000000..c7575b423cd2217cfda26631ce64ad66d5bb5ccb Binary files /dev/null and b/graph-theory/source/examples/images/3-3-cart-traffic-jam_initial.png differ diff --git a/graph-theory/source/examples/images/3-3-traffic-jam-road-map.png b/graph-theory/source/examples/images/3-3-traffic-jam-road-map.png new file mode 100644 index 0000000000000000000000000000000000000000..c9ffb1c2b215c1ca5bf75bdf811605a80e7db454 Binary files /dev/null and b/graph-theory/source/examples/images/3-3-traffic-jam-road-map.png differ diff --git a/graph-theory/source/examples/images/3-3-tree-of-states.png b/graph-theory/source/examples/images/3-3-tree-of-states.png new file mode 100644 index 0000000000000000000000000000000000000000..c8605ff546a1dc5175a2a1d188b52f9f04533152 Binary files /dev/null and b/graph-theory/source/examples/images/3-3-tree-of-states.png differ diff --git a/graph-theory/source/examples/images/6nodes.png b/graph-theory/source/examples/images/6nodes.png new file mode 100644 index 0000000000000000000000000000000000000000..db05dbd77a0d2883321b5cacd74da37d94970d7d Binary files /dev/null and b/graph-theory/source/examples/images/6nodes.png differ diff --git a/graph-theory/source/examples/images/Torniqueterevolution.jpg b/graph-theory/source/examples/images/Torniqueterevolution.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a40b7320e18f8144e6f5b033548ad29b9578deae Binary files /dev/null and b/graph-theory/source/examples/images/Torniqueterevolution.jpg differ diff --git a/graph-theory/source/examples/images/cpm_w_artificial_dependency.png b/graph-theory/source/examples/images/cpm_w_artificial_dependency.png new file mode 100644 index 0000000000000000000000000000000000000000..ef68aa4db611990eb9d69fa0dbfee854cca1a62b Binary files /dev/null and b/graph-theory/source/examples/images/cpm_w_artificial_dependency.png differ diff --git a/graph-theory/source/examples/images/cpm_wo_artificial_dependency.png b/graph-theory/source/examples/images/cpm_wo_artificial_dependency.png new file mode 100644 index 0000000000000000000000000000000000000000..be8945206c810f63d6da1c30a629afdd507d2638 Binary files /dev/null and b/graph-theory/source/examples/images/cpm_wo_artificial_dependency.png differ diff --git a/graph-theory/source/examples/images/easy_sudoku.png b/graph-theory/source/examples/images/easy_sudoku.png new file mode 100644 index 0000000000000000000000000000000000000000..81b0bb88c26173b05cd9d128d3398d1bbdd55c7d Binary files /dev/null and b/graph-theory/source/examples/images/easy_sudoku.png differ diff --git a/graph-theory/source/examples/images/easy_sudoku3.png b/graph-theory/source/examples/images/easy_sudoku3.png new file mode 100644 index 0000000000000000000000000000000000000000..dfc21c0b5e1cff43cb1658351fa04ebe5b040c20 Binary files /dev/null and b/graph-theory/source/examples/images/easy_sudoku3.png differ diff --git a/graph-theory/source/examples/images/movement_graph.png b/graph-theory/source/examples/images/movement_graph.png new file mode 100644 index 0000000000000000000000000000000000000000..d6aee85f13b0052380828753583094f792a3e03a Binary files /dev/null and b/graph-theory/source/examples/images/movement_graph.png differ diff --git a/graph-theory/source/examples/images/search_tree.png b/graph-theory/source/examples/images/search_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..fb11ffce5ff19aabf2441635fe103bfc8ff6f4c3 Binary files /dev/null and b/graph-theory/source/examples/images/search_tree.png differ diff --git a/graph-theory/source/examples/images/sudoku-wave-collapse-1.png b/graph-theory/source/examples/images/sudoku-wave-collapse-1.png new file mode 100644 index 0000000000000000000000000000000000000000..d6418bd43cde4d2ca7583de56fec7494394b795e Binary files /dev/null and b/graph-theory/source/examples/images/sudoku-wave-collapse-1.png differ diff --git a/graph-theory/source/examples/images/sudoku_solver1.png b/graph-theory/source/examples/images/sudoku_solver1.png new file mode 100644 index 0000000000000000000000000000000000000000..b039ef22d6bc227f41075431282123f5beef1283 Binary files /dev/null and b/graph-theory/source/examples/images/sudoku_solver1.png differ diff --git a/graph-theory/source/examples/images/tjs-map-loads.png b/graph-theory/source/examples/images/tjs-map-loads.png new file mode 100644 index 0000000000000000000000000000000000000000..bb3dd80e996a4ee72007f052ea1e035018430503 Binary files /dev/null and b/graph-theory/source/examples/images/tjs-map-loads.png differ diff --git a/graph-theory/source/examples/images/tjs-map.png b/graph-theory/source/examples/images/tjs-map.png new file mode 100644 index 0000000000000000000000000000000000000000..35939d04e3c08a225940483cd57adeead615916d Binary files /dev/null and b/graph-theory/source/examples/images/tjs-map.png differ diff --git a/graph-theory/source/examples/images/tjs_problem_w_distance_restrictions.png b/graph-theory/source/examples/images/tjs_problem_w_distance_restrictions.png new file mode 100644 index 0000000000000000000000000000000000000000..c3d46737495311a83db014f00e1ecca39f94e363 Binary files /dev/null and b/graph-theory/source/examples/images/tjs_problem_w_distance_restrictions.png differ diff --git a/graph-theory/source/examples/images/traffic_bi_directional.gif b/graph-theory/source/examples/images/traffic_bi_directional.gif new file mode 100644 index 0000000000000000000000000000000000000000..4fdf2a93a1097ef7eb5b155efc4b2c03e055a259 --- /dev/null +++ b/graph-theory/source/examples/images/traffic_bi_directional.gif @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:729a16f3a2f13959bba67694a9659da3637ea551539f30533716b2fd3f88d713 +size 591285 diff --git a/graph-theory/source/examples/images/turnstile.png b/graph-theory/source/examples/images/turnstile.png new file mode 100644 index 0000000000000000000000000000000000000000..2f99097148a4eef7b3acdc01e2345ff47cfbcb31 Binary files /dev/null and b/graph-theory/source/examples/images/turnstile.png differ diff --git a/graph-theory/source/examples/readme.md b/graph-theory/source/examples/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..f7b3a4ddd6b23e3f833d6b1e1ae2d53ab5730a36 --- /dev/null +++ b/graph-theory/source/examples/readme.md @@ -0,0 +1,89 @@ +# Graph-theory examples + +This folder contains jupyter notebooks, with examples from +graph-theory. + +If you're new to the field I would recommend to study (loosely) +in the order below: + +***[basic graph theory](basic%20graph%20theory.ipynb)***: An introduction to the fundamental +terminology of graph-theory. Topics are: + + nodes + edges + indegree + outdegree + has_path + distance path + is a subgraph + examples of existing graphs available for testing. + +***[generating and visualising graphs](generating%20and%20visualising%20graphs.ipynb)***: An introduction +to making random xy graphs, grids and visualise them. + +***[comparing graphs](comparing%20graphs.ipynb)***: An overview of methods for comparing +graphs, such as: + + topological sort + phase lines + graph-hash + flow_graph_hash + merkle-tree + + +***[solving search problems](solving%20search%20problems.ipynb)***: An introduction to different +methods for findings paths, including: + + adjacency matrix + BFS + DFS + DFScan + bidi-BFS + TSP + [critical path method] + find loops + +***[calculating statistics about graphs](statistics%20on%20graphs.ipynb)*** provides an overview +of common analysis of graphs, such as: + + components + has cycles + network size + is partite + degree of separation + + +***[solving transport problems](solving%20search%20problems.ipynb)*** provides tools for a wide range +of problems where discrete transport is essential. + + minmax + minsum + shortest_tree all pairs. + scheduling problem + traffic scheduling problem + jam solver + trans shipment problem (needs rewrite) + + +***[solving flow problems](solving%20flow%20problems.ipynb)*** provides tools for solving a +wide range of problems where continuous flow are central. + + max flow + max flow min cut + min cost flow + all_simple_paths + all_paths + + +***[solving assignment problems](solving%20assignment%20problems.ipynb)*** provides tools for solving +any kind of assignment problem. + + assignment problem + wtap + + +***[representing systems as graphs](graphs%20as%20finite%20state%20machines.ipynb)*** provides a use case +for using `graph as finite state machine`. + + + diff --git a/graph-theory/source/examples/solving assignment problems.ipynb b/graph-theory/source/examples/solving assignment problems.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f57469488ff73a01cd424ca9ba89a6b046d72a8b --- /dev/null +++ b/graph-theory/source/examples/solving assignment problems.ipynb @@ -0,0 +1,36 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/graph-theory/source/examples/solving flow problems.ipynb b/graph-theory/source/examples/solving flow problems.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f57469488ff73a01cd424ca9ba89a6b046d72a8b --- /dev/null +++ b/graph-theory/source/examples/solving flow problems.ipynb @@ -0,0 +1,36 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/graph-theory/source/examples/solving search problems.ipynb b/graph-theory/source/examples/solving search problems.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..542670f13aaee59f4fc5a232436581b6dac5cf54 --- /dev/null +++ b/graph-theory/source/examples/solving search problems.ipynb @@ -0,0 +1,652 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Solving search problem.\n", + "\n", + "An introduction to different methods for findings paths, including:\n", + "\n", + "\tadjacency matrix\n", + "\tBFS\n", + " find loops\n", + "\tDFS\n", + " DFScan\n", + "\tbidi-BFS\n", + "\tTSP\n", + "\t[critical path method]\n", + "\t\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First things first. Let's load the imports for this chapter" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from graph import Graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The adjacency matrix\n", + "\n", + "an adjacency matrix is a square matrix used to represent a finite graph. The elements of the matrix indicate whether pairs of vertices are adjacent or not in the graph.\n", + "\n", + " The distance from a node to itself is 0 and distance from a node to\n", + " an unconnected node is defined to be infinite. This does not mean that there\n", + " is no path from a node to another via other nodes.\n", + "\n", + "```\n", + "Example:\n", + " g = Graph(from_dict=\n", + " {1: {2: 3, 3: 8, 5: -4},\n", + " 2: {4: 1, 5: 7},\n", + " 3: {2: 4},\n", + " 4: {1: 2, 3: -5},\n", + " 5: {4: 6}})\n", + "\n", + " adjacency_matrix(g)\n", + " {1: {1: 0, 2: 3, 3: 8, 4: inf, 5: -4},\n", + " 2: {1: inf, 2: 0, 3: inf, 4: 1, 5: 7},\n", + " 3: {1: inf, 2: 4, 3: 0, 4: inf, 5: inf},\n", + " 4: {1: 2, 2: inf, 3: -5, 4: 0, 5: inf},\n", + " 5: {1: inf, 2: inf, 3: inf, 4: 6, 5: 0}}\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The adjacency matrix is very helpful when we want to compute the all pairs shortest path.\n", + "\n", + "Find the cost of the shortest path between every pair of vertices in a\n", + " weighted graph. Uses the Floyd-Warshall algorithm.\n", + "\n", + " Example:\n", + " inf = float('inf')\n", + " g = Graph(from_dict=(\n", + " {0: {0: 0, 1: 1, 2: 4},\n", + " 1: {0: inf, 1: 0, 2: 2},\n", + " 2: {0: inf, 1: inf, 2: 0}})\n", + "\n", + " fw(g)\n", + " {0: {0: 0, 1: 1, 2: 3},\n", + " 1: {0: inf, 1: 0, 2: 2},\n", + " 2: {0: inf, 1: inf, 2: 0}}\n", + "\n", + " h = {1: {2: 3, 3: 8, 5: -4},\n", + " 2: {4: 1, 5: 7},\n", + " 3: {2: 4},\n", + " 4: {1: 2, 3: -5},\n", + " 5: {4: 6}}\n", + "\n", + " fw(adj(h)) #\n", + " {1: {1: 0, 2: 1, 3: -3, 4: 2, 5: -4},\n", + " 2: {1: 3, 2: 0, 3: -4, 4: 1, 5: -1},\n", + " 3: {1: 7, 2: 4, 3: 0, 4: 5, 5: 3},\n", + " 4: {1: 2, 2: -1, 3: -5, 4: 0, 5: -2},\n", + " 5: {1: 8, 2: 5, 3: 1, 4: 6, 5: 0}}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Distance maps\n", + "\n", + "As you can see the adjacency matrix computes the whole graph, but often this isn't necessary. So I invented the distance map as \"light weight\" version of the adjacency matrix. Here is how it works:\n", + "\n", + "We have a 4x4 graph like this:\n", + "\n", + " 1 -> 2 -> 3 -> 4\n", + " | | | |\n", + " v v v v\n", + " 5 -> 6 -> 7 -> 8\n", + " | | | |\n", + " v v v v\n", + " 9 -> 10-> 11-> 12\n", + " | | | |\n", + " v v v v\n", + " 13-> 14-> 15-> 16\n", + "\n", + "And we would like to go the shortest distance between _some_ points.\n", + "\n", + "Arbitrarily we pick 3 or 5 as starts and decide to go to either 12 or 14.\n", + "\n", + "The objective is to choose ANY shortest path." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{3: 0,\n", + " 5: 0,\n", + " 2: 1,\n", + " 4: 1,\n", + " 7: 1,\n", + " 1: 1,\n", + " 6: 1,\n", + " 9: 1,\n", + " 8: 2,\n", + " 11: 2,\n", + " 10: 2,\n", + " 13: 2,\n", + " 12: 3,\n", + " 15: 3,\n", + " 14: 3,\n", + " 16: 4}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "edges = [\n", + " (1, 2, 1), (2, 3, 1), (3, 4, 1), (1, 5, 1),\n", + " (5, 6, 1), (6, 7, 1), (7, 8, 1), (2, 6, 1),\n", + " (3, 7, 1), (4, 8, 1), (5, 9, 1), (9, 10, 1),\n", + " (10, 11, 1), (11, 12, 1), (6, 10, 1), (7, 11, 1),\n", + " (8, 12, 1), (9, 13, 1), (13, 14, 1), (14, 15, 1),\n", + " (15, 16, 1), (10, 14, 1), (11, 15, 1), (12, 16, 1)\n", + "]\n", + "g = Graph()\n", + "for s, e, d in edges:\n", + " g.add_edge(s, e, d, bidirectional=True)\n", + " \n", + "g.distance_map(starts=[3, 5], ends=[12, 14])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The distance map returns a dictionary with the distance from 3 and 5 traveling towards 12 and 14. \n", + "\n", + "Think of this map as a landscape, where the `starts` are at the bottom and then you want to \"walk\" towards either 12 or 14 following the path of least resistance." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In my experience a lot of people are initially confused about the all-pairs shortest path, and it's usage.\n", + "\n", + "Let's compare it with two other methods:\n", + "\n", + "minsum: finds the mode(s) that have the smallest sum of distance to all other nodes\n", + "\n", + "minmax: finds the node(s) with shortest distance to all other nodes. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Breadth First Search (BFS)\n", + "\n", + "Breadth-first search (BFS) is an algorithm for searching a tree data structure for a node that satisfies a given property. It starts at the tree root and explores all nodes at the present depth prior to moving on to the nodes at the next depth level. Extra memory, usually a queue, is needed to keep track of the child nodes that were encountered but not yet explored.\n", + "\n", + "A simple example is where you are searching for the nearest gas station on a map: You start with your current position and follow the roads in all directions until you meet an intersection. You repeat this \"extension\" until you find a gas station.\n", + "\n", + "BFS on a map is very easy to understand. But what if you don't have a map? What if you only know where you can go?\n", + "\n", + "For example, in a chess endgame a chess engine may build the game tree from the current position by applying all possible moves, and use breadth-first search to find a win position for white. Implicit trees (such as game trees or other problem-solving trees) may be of infinite size; breadth-first search is guaranteed to find a solution node if one exists.\n", + "\n", + "A slightly simpler case is the search for a solution of the tile-slide puzzle.\n", + "\n", + "We can describe the state of a system by it's options as a graph:\n", + "\n", + "```\n", + " A B\n", + "[1] --- [2]\n", + " | |\n", + " | |\n", + "[4] --- [3]\n", + "```\n", + "With tiles on position `[1]` and `[2]` where A is in 1 and B is in 2.\n", + "Let's find a way for A to move to 3 and B to move to 4.\n", + "\n", + "First we create the graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "g = Graph()\n", + "for s,e in zip([1,2,3,4], [2,3,4,1]):\n", + " g.add_edge(s,e,1,bidirectional=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we define the `initial state` and `end state`:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "s1 = (('A',1), ('B',2))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "end = (('A',3),('B',4))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now `A` can't move from 1 via 2 to 3, as `B` blocks the way.\n", + "Similarly `B` can't move from 2 via 1 to 3, as `A` blocks the way.\n", + "So we need generate a tree using BFS as foundation for our search.\n", + "\n", + "the search will look like this:\n", + "\n", + "![search tree](images/search_tree.png)\n", + "\n", + "but as you see there is some redunancy in the search tree, it is better to create a graph of movements:\n", + "\n", + "![movements](images/movement_graph.png)\n", + "\n", + "We can now search for the shortest path from the `initial state` to the `end state` in the movements graph:\n", + "\n", + "This is the code from graph-theory" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from graph.bfs import breadth_first_search\n", + "import inspect" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "def breadth_first_search(graph, start, end):\n", + " \"\"\"Determines the path from start to end with fewest nodes.\n", + " :param graph: class Graph\n", + " :param start: start node\n", + " :param end: end node\n", + " :return: path\n", + " \"\"\"\n", + " if not isinstance(graph, BasicGraph):\n", + " raise TypeError(f\"Expected BasicGraph, Graph or Graph3D, not {type(graph)}\")\n", + " if start not in graph:\n", + " raise ValueError(f\"{start} not in graph\")\n", + " if end not in graph:\n", + " raise ValueError(f\"{end} not in graph\")\n", + "\n", + " visited = {start: None}\n", + " q = deque([start])\n", + " while q:\n", + " node = q.popleft()\n", + " if node == end:\n", + " path = deque()\n", + " while node is not None:\n", + " path.appendleft(node)\n", + " node = visited[node]\n", + " return list(path)\n", + " for next_node in graph.nodes(from_node=node):\n", + " if next_node not in visited:\n", + " visited[next_node] = node\n", + " q.append(next_node)\n", + " return []\n", + "\n" + ] + } + ], + "source": [ + "print(inspect.getsource(breadth_first_search))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Explanation of the code**\n", + "\n", + "`breadth_first_search` starts with the `start` (our `initial state`) and `end` (our `end state`) and puts `start` into a `deque`.\n", + "\n", + "```\n", + "def breadth_first_search(graph, start, end):\n", + " visited = {start: None}\n", + " q = deque([start])\n", + "```\n", + "Then it enters the `while` loop and runs as long as there's node in the queue.\n", + "```\n", + " while q:\n", + " node = q.popleft()\n", + " if node == end:\n", + "```\n", + "The algorithm then removes the first item from the queue using `popleft`, and checks whether it's the `end`. If it isn't, the search continues:\n", + "\n", + "We take each node that the popped `node` is connected to and check if we have seen it before. If we have seen it before we just continue to the next node. If we haven't seen it before we add it to the queue.\n", + "```\n", + " for next_node in graph.nodes(from_node=node):\n", + " if next_node not in visited:\n", + " visited[next_node] = node\n", + " q.append(next_node)\n", + "```\n", + "Finally when the `end` is the node we are looking for we can terminate the search." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### finding loops" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Depth First Search (DFS)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Bidirectional breadth first search (BidiBFS)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jupyter": { + "outputs_hidden": true + } + }, + "source": [ + "## Critical path method\n", + "\n", + "The [critical path method](https://en.wikipedia.org/wiki/Critical_path_method) (CPM), or critical path analysis (CPA), is an algorithm for scheduling a set of project activities.\n", + "\n", + "A critical path is determined by identifying the longest stretch of dependent activities and, commonly, measuring the time required to complete them from start to finish.\n", + "\n", + "An example is shown below where the critical path constitutes the path ABCDE:\n", + "\n", + "![w](images/cpm_wo_artificial_dependency.png)\n", + "\n", + "We can load these values into a Graph as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "tasks = {'A': 10, 'B': 20, 'C': 5, 'D': 10, 'E': 20, 'F': 15, 'G': 5, 'H': 15}\n", + "dependencies = [\n", + " ('A', 'B'),\n", + " ('B', 'C'),\n", + " ('C', 'D'),\n", + " ('D', 'E'),\n", + " ('A', 'F'),\n", + " ('F', 'G'),\n", + " ('G', 'E'),\n", + " ('A', 'H'),\n", + " ('H', 'E'),\n", + "]\n", + "\n", + "g = Graph()\n", + "for n, d in tasks.items():\n", + " g.add_node(n, obj=d)\n", + "for n1, n2 in dependencies:\n", + " g.add_edge(n1, n2, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And we can calculate the schedule and the length of the critical path as:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "critical_path_length, schedule = g.critical_path()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The critical path has duration 65\n" + ] + } + ], + "source": [ + "print(\"The critical path has duration\", critical_path_length)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The tasks are:\n", + "A Task('A', 10, 0, 0, 10, 10)\n", + "B Task('B', 20, 10, 10, 30, 30)\n", + "C Task('C', 5, 30, 30, 35, 35)\n", + "D Task('D', 10, 35, 35, 45, 45)\n", + "E Task('E', 20, 45, 45, 65, 65)\n", + "F Task('F', 15, 10, 25, 25, 40)\n", + "G Task('G', 5, 25, 40, 30, 45)\n", + "H Task('H', 15, 10, 30, 25, 45)\n" + ] + } + ], + "source": [ + "print(\"The tasks are:\")\n", + "from graph.critical_path import Task\n", + "for task_id, task in sorted(schedule.items()):\n", + " print(task_id, task)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The properties of each `Task` are:\n", + "\n", + "- task id\n", + "- duration \n", + "- earliest start time\n", + "- latest start time\n", + "- earliest finish time\n", + "- latest finish time.\n", + "\n", + "and the slack in the schedule can be calculated as:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The total slack in the schedule is 50\n" + ] + } + ], + "source": [ + "slack = sum(t.slack for t in schedule.values())\n", + "\n", + "print(\"The total slack in the schedule is\", slack)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Minimising slack\n", + "\n", + "In cases where the tasks are commodities, such as CPU time, it can be convenient to minimise the number of concurrently active resources.\n", + "\n", + "As you may have noticed above in the diagram, the dependencies indicate that the graph has 3 paths at it's widest, whereby it would be logical to assign 3 CPUs to compute the tasks. However a little search can illustrate that it is possible to solve the tasks with 2 CPUs without extending the critical path.\n", + "\n", + "This can be done by inserting artificial dependencies. Here is an example:\n", + "\n", + "![wo](images/cpm_w_artificial_dependency.png)\n", + "\n", + "The method to minimise the slack, is conveniently called `critical_path_minimize_for_slack` and this is how it is used:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "jupyter": { + "outputs_hidden": false + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "g2 = g.critical_path_minimize_for_slack()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can verify that the critical path length is the same, and we can verify that this schedule does indeed have less slack:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The total slack in the schedule was 50 and is now 0\n" + ] + } + ], + "source": [ + "critical_path_length2, schedule2 = g2.critical_path()\n", + "\n", + "slack2 = sum(t.slack for t in schedule2.values())\n", + "\n", + "print(\"The total slack in the schedule was\", slack, \"and is now\", slack2)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The tasks remain the same, though with changed timings::\n", + "A Task('A', 10, 0, 0, 10, 10)\n", + "B Task('B', 20, 10, 10, 30, 30)\n", + "C Task('C', 5, 30, 30, 35, 35)\n", + "D Task('D', 10, 35, 35, 45, 45)\n", + "E Task('E', 20, 45, 45, 65, 65)\n", + "F Task('F', 15, 25, 25, 40, 40)\n", + "G Task('G', 5, 40, 40, 45, 45)\n", + "H Task('H', 15, 10, 10, 25, 25)\n" + ] + } + ], + "source": [ + "print(\"The tasks remain the same, though with changed timings::\")\n", + "from graph.critical_path import Task\n", + "for task_id, task in sorted(schedule2.items()):\n", + " print(task_id, task)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/graph-theory/source/examples/solving transport problems.ipynb b/graph-theory/source/examples/solving transport problems.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f57469488ff73a01cd424ca9ba89a6b046d72a8b --- /dev/null +++ b/graph-theory/source/examples/solving transport problems.ipynb @@ -0,0 +1,36 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/graph-theory/source/examples/statistics on graphs.ipynb b/graph-theory/source/examples/statistics on graphs.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f57469488ff73a01cd424ca9ba89a6b046d72a8b --- /dev/null +++ b/graph-theory/source/examples/statistics on graphs.ipynb @@ -0,0 +1,36 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/graph-theory/source/graph/__init__.py b/graph-theory/source/graph/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f442396f096e1e12bb6cd19890f5610a70fc25a8 --- /dev/null +++ b/graph-theory/source/graph/__init__.py @@ -0,0 +1,2 @@ +from .core import Graph, Graph3D +from .base import same_path diff --git a/graph-theory/source/graph/adjacency_matrix.py b/graph-theory/source/graph/adjacency_matrix.py new file mode 100644 index 0000000000000000000000000000000000000000..f06249492b992f3b21fc816b6db1a2fa308bf8ae --- /dev/null +++ b/graph-theory/source/graph/adjacency_matrix.py @@ -0,0 +1,31 @@ +from .base import BasicGraph + + +def adjacency_matrix(graph): + """Converts directed graph to an adjacency matrix. + :param graph: + :return: dictionary + The distance from a node to itself is 0 and distance from a node to + an unconnected node is defined to be infinite. This does not mean that there + is no path from a node to another via other nodes. + Example: + g = Graph(from_dict= + {1: {2: 3, 3: 8, 5: -4}, + 2: {4: 1, 5: 7}, + 3: {2: 4}, + 4: {1: 2, 3: -5}, + 5: {4: 6}}) + adjacency_matrix(g) + {1: {1: 0, 2: 3, 3: 8, 4: inf, 5: -4}, + 2: {1: inf, 2: 0, 3: inf, 4: 1, 5: 7}, + 3: {1: inf, 2: 4, 3: 0, 4: inf, 5: inf}, + 4: {1: 2, 2: inf, 3: -5, 4: 0, 5: inf}, + 5: {1: inf, 2: inf, 3: inf, 4: 6, 5: 0}} + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + return { + v1: {v2: 0 if v1 == v2 else graph.edge(v1, v2, default=float("inf")) for v2 in graph.nodes()} + for v1 in graph.nodes() + } diff --git a/graph-theory/source/graph/all_pairs_shortest_path.py b/graph-theory/source/graph/all_pairs_shortest_path.py new file mode 100644 index 0000000000000000000000000000000000000000..5ca8bb30a2192464024239b424bbd193ee831019 --- /dev/null +++ b/graph-theory/source/graph/all_pairs_shortest_path.py @@ -0,0 +1,38 @@ +from .base import BasicGraph + + +def all_pairs_shortest_paths(graph): + """Find the cost of the shortest path between every pair of vertices in a + weighted graph. Uses the Floyd-Warshall algorithm. + Example: + inf = float('inf') + g = Graph(from_dict=( + {0: {0: 0, 1: 1, 2: 4}, + 1: {0: inf, 1: 0, 2: 2}, + 2: {0: inf, 1: inf, 2: 0}}) + fw(g) + {0: {0: 0, 1: 1, 2: 3}, + 1: {0: inf, 1: 0, 2: 2}, + 2: {0: inf, 1: inf, 2: 0}} + h = {1: {2: 3, 3: 8, 5: -4}, + 2: {4: 1, 5: 7}, + 3: {2: 4}, + 4: {1: 2, 3: -5}, + 5: {4: 6}} + fw(adj(h)) # + {1: {1: 0, 2: 1, 3: -3, 4: 2, 5: -4}, + 2: {1: 3, 2: 0, 3: -4, 4: 1, 5: -1}, + 3: {1: 7, 2: 4, 3: 0, 4: 5, 5: 3}, + 4: {1: 2, 2: -1, 3: -5, 4: 0, 5: -2}, + 5: {1: 8, 2: 5, 3: 1, 4: 6, 5: 0}} + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + + g = graph.adjacency_matrix() + assert isinstance(g, dict), "previous function should have returned a dict." + vertices = g.keys() + + for v2 in vertices: + g = {v1: {v3: min(g[v1][v3], g[v1][v2] + g[v2][v3]) for v3 in vertices} for v1 in vertices} + return g diff --git a/graph-theory/source/graph/all_paths.py b/graph-theory/source/graph/all_paths.py new file mode 100644 index 0000000000000000000000000000000000000000..0efafaa64877e06d3233e3004703de02d2853f70 --- /dev/null +++ b/graph-theory/source/graph/all_paths.py @@ -0,0 +1,67 @@ +from .base import BasicGraph + + +from collections import deque + + +def all_paths(graph, start, end): + """finds all paths from start to end by traversing each fork once only. + :param graph: instance of Graph + :param start: node + :param end: node + :return: list of paths unique from start to end. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + if start not in graph: + raise ValueError("start not in graph.") + if end not in graph: + raise ValueError("end not in graph.") + if start == end: + raise ValueError("start is end") + + cache = {} + if not graph.is_connected(start, end): + return [] + paths = [(start,)] + q = deque([start]) + skip_list = set() + while q: + n1 = q.popleft() + if n1 == end: + continue + + n2s = graph.nodes(from_node=n1) + new_paths = [p for p in paths if p[-1] == n1] + for n2 in n2s: + if n2 in skip_list: + continue + n3s = graph.nodes(from_node=n2) + + con = cache.get((n2, n1)) + if con is None: + con = graph.is_connected(n2, n1) + cache[(n2, n1)] = con + + if len(n3s) > 1 and con: + # it's a fork and it's a part of a loop! + # is the sequence n2,n3 already in the path? + for n3 in n3s: + for path in new_paths: + a = [n2, n3] + if any(all(path[i + j] == a[j] for j in range(len(a))) for i in range(len(path))): + skip_list.add(n3) + + for path in new_paths: + if path in paths: + paths.remove(path) + + new_path = path + (n2,) + if new_path not in paths: + paths.append(new_path) + + if n2 not in q: + q.append(n2) + + paths = [list(p) for p in paths if p[-1] == end] + return paths \ No newline at end of file diff --git a/graph-theory/source/graph/all_simple_paths.py b/graph-theory/source/graph/all_simple_paths.py new file mode 100644 index 0000000000000000000000000000000000000000..08a88b991424813fc0a92c62ba12d7b697aaead4 --- /dev/null +++ b/graph-theory/source/graph/all_simple_paths.py @@ -0,0 +1,38 @@ +from .base import BasicGraph + + +from collections import deque + + +def all_simple_paths(graph, start, end): + """ + finds all simple (non-looping) paths from start to end + :param start: node + :param end: node + :return: list of paths + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError("start not in graph.") + if end not in graph: + raise ValueError("end not in graph.") + if start == end: + raise ValueError("start is end") + + if not graph.is_connected(start, end): + return [] + + paths = [] + q = deque([(start,)]) + while q: + path = q.popleft() + for s, e, d in graph.edges(from_node=path[0]): + if e in path: + continue + new_path = (e,) + path + if e == end: + paths.append(new_path) + else: + q.append(new_path) + return [list(reversed(p)) for p in paths] \ No newline at end of file diff --git a/graph-theory/source/graph/assignment_problem.py b/graph-theory/source/graph/assignment_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..50b90e1f51693ac368e2d5b4d747b5784f6131f7 --- /dev/null +++ b/graph-theory/source/graph/assignment_problem.py @@ -0,0 +1,228 @@ +from uuid import uuid4 + +from .base import BasicGraph + +__all__ = ['ap_solver', 'wtap_solver'] + + +def ap_solver(graph): + """ + + ASSIGNMENT PROBLEM + + Definition: + + The problem instance has a number of agents and a number of tasks. + Any agent can be assigned to perform any task, incurring some cost that may + vary depending on the agent-task assignment. It is required to perform all + tasks by assigning exactly one agent to each task and exactly one task to each + agent in such a way that the total cost of the assignment is minimized.[1] + + Variations: + + - If there are more agents than tasks the problem can be solved by creating a + "do nothing tasks" with a cost of zero. The assignment problem solver does this + automatically. + + - If there are more tasks than agents then the problem is a knapsack problem. + The assignment problem solver handles this case gracefully too. + + Solution methods: + + 1. Using maximum flow method. + 2. Using alternating iterative auction. + + [1] https://en.wikipedia.org/wiki/Assignment_problem + + ---------------------------------------------------- + + The assignment problem solver expects a bi-partite graph + with agents, tasks and the value/cost of each task, as links, + so that the relationship is explicit as: + + value = g.edge(agent 1, task 1) + + The optimal assignment is determined as an alternating auction + (see Dmitri Bertsekas, MIT) which maximises the value. + Once all agents are assigned the alternating auction halts. + + :param graph: Graph + :return: optimal assignment as list of edges (agent, task, value) + """ + assert isinstance(graph, BasicGraph) + agents = [n for n in graph.nodes(in_degree=0)] + tasks = [n for n in graph.nodes(out_degree=0)] + + unassigned_agents = agents + v_null = min(v for a, t, v in graph.edges()) - 1 + + dummy_tasks = set() + if len(agents) > len(tasks): # make dummy tasks. + dummy_tasks_needed = len(agents) - len(tasks) + + for i in range(dummy_tasks_needed): + task = uuid4().hex + dummy_tasks.add(task) + tasks.append(task) + for agent in agents: + graph.add_edge(agent, task, v_null) + v_null -= 1 + + unassigned_tasks = set(tasks) + cls = type(graph) + assignments = cls() + + while unassigned_agents: + n = unassigned_agents.pop(0) # select phase: + value_and_task_for_n = [(v, t) for a, t, v in graph.edges(from_node=n)] + value_and_task_for_n.sort(reverse=True) + for v, t in value_and_task_for_n: # for each opportunity (in ranked order) + d = v_null + for s, e, d in assignments.edges(from_node=t): # if connected, get whoever it is connected to. + break + + if v > d: # if the opportunity is better. + if t in assignments: # and if there is a previous relationship. + unassigned_agents.append(e) # add the removed node to unassigned. + assignments.del_edge(t, e) # erase any previous relationship. + else: + unassigned_tasks.remove(t) + assignments.add_edge(t, n, v) # record the new relationship. + break + + return [(a, t, v) for t, a, v in assignments.edges() if t not in dummy_tasks] + + +def wtap_solver(probabilities, weapons, target_values): + """ + Definition: + + Weapons target assignment problem (WTAP) + + The problem instance has a number weapons which can be assigned + to engage targets, with a success rate of P(x). Targets have values V. + If a weapon is engaged against a target, and is successful, the value is + reduced to zero. Expected outcome of an engagement (D,T) is thereby + + O = V * (1-P(x)) + + The optimal assignment is minimises the value of the targets. + + min E( O ) + + for more see: https://en.wikipedia.org/wiki/Weapon_target_assignment_problem + + Variations: + + - if V is unknown, use v = 1. This maximises the exploitation of the available + probabilities. + + Method used: + + 1. initial assignment using greedy algorithm; + 2. followed by search for improvements. + + ---------------- + + :param probabilities: instance of Graph, where the relationship + between weapons and targets is given as the probability to a + successful engagement of the device. + :param weapons: list of devices. + :param target_values: dict , where the d[target] = value of target. + :return: tuple: value of target after attack, optimal assignment + + """ + assert isinstance(probabilities, BasicGraph) + assert isinstance(weapons, list) + assert isinstance(target_values, dict) + # first: verify internal integrity of inputs. + weaponset = set(weapons) + targetset = set(target_values) + id_overlap = weaponset.intersection(targetset) + if id_overlap: + raise ValueError(f"weapon ids in target_values for {id_overlap}") + target_prob_set = {e for s, e, d in probabilities.edges()} + if targetset > target_prob_set: + raise ValueError(f"targets have no probabilities: {targetset-target_prob_set}") + + # second: clear the memory from the validations. + weaponset.clear() + targetset.clear() + target_prob_set.clear() + + # then: Calculate the solution. + cls = type(probabilities) + assignments = cls() + current_target_values = sum(target_values.values()) + 1 + + improvements = {} + while True: + for w in weapons: + # calculate the effect of engaging in all targets. + effect_of_assignment = {} + for _, t, p in probabilities.edges(from_node=w): + current_engagement = _get_current_engagement(w, assignments) + if current_engagement != t: + if w in assignments and current_engagement is not None: + assignments.del_edge(w, current_engagement) + assignments.add_edge(w, t, value=probabilities.edge(w, t)) + effect_of_assignment[t] = _damages(probabilities=probabilities, + assignment=assignments, + target_values=target_values) + + damage_and_targets = [(v, t) for t, v in effect_of_assignment.items()] + damage_and_targets.sort() + best_alt_damage, best_alt_target = damage_and_targets[0] + nett_effect = current_target_values - best_alt_damage + improvements[w] = max(0, nett_effect) + + current_engagement = _get_current_engagement(w, assignments) + if current_engagement != best_alt_target: + if w in assignments and current_engagement is not None: + assignments.del_edge(w, current_engagement) + assignments.add_edge(w, best_alt_target, probabilities.edge(w, best_alt_target)) + current_target_values = effect_of_assignment[best_alt_target] + if sum(improvements.values()) == 0: + break + return current_target_values, assignments + + +def _get_current_engagement(d, assignment): + """ helper for WTAP solver + Calculates the current engagement + :param d: device + :param assignment: class Graph. + :return: + """ + if d in assignment: + for d, t, v in assignment.edges(from_node=d): + return t + return None + + +def _damages(probabilities, assignment, target_values): + """ helper for WTAP solver + :param probabilities: graph with probability of device effect on target + :param assignment: graph with links between device and targets. + :param target_values: dict with [target]=value. + :return: total survival value. + """ + assert isinstance(probabilities, BasicGraph) + assert isinstance(assignment, BasicGraph) + assert isinstance(target_values, dict) + + survival_value = {target: [] for target in target_values} + for edge in assignment.edges(): + weapon, target, damage = edge + + p = probabilities.edge(weapon, target) + survival_value[target].append(p) + + total_survival_value = 0 + for target, assigned_probabilities in survival_value.items(): + p = 1 + for p_ in assigned_probabilities: + p *= (1 - p_) + total_survival_value += p * target_values[target] + + return total_survival_value \ No newline at end of file diff --git a/graph-theory/source/graph/base.py b/graph-theory/source/graph/base.py new file mode 100644 index 0000000000000000000000000000000000000000..effaeea849f145043eb1bae6d5dfb97e2164a720 --- /dev/null +++ b/graph-theory/source/graph/base.py @@ -0,0 +1,521 @@ +from itertools import chain +from collections import defaultdict, deque +from collections.abc import Iterable + + +class BasicGraph(object): + """ + BasicGraph is the base graph that all methods use. + For methods, please see the documentation on the + individual functions, by importing them separately. + """ + + def __init__(self, from_dict=None, from_list=None): + """ + :param from_dict: creates graph for dictionary {n1:{n2:d} ... + :param from_list: creates graph from list of edges(n1,n2,d) + """ + self._nodes = {} + self._edges = {} + self._edge_count = 0 + self._reverse_edges = {} + self._in_degree = defaultdict(int) + self._out_degree = defaultdict(int) + + if from_dict is not None: + self.from_dict(from_dict) + elif from_list is not None: + self.from_list(from_list) + + def __str__(self): + return f"{self.__class__.__name__}({len(self._nodes)} nodes, {self._edge_count} edges)" + + def __eq__(self, other): + if not isinstance(other, self.__class__): + return False + if self._nodes != other._nodes: + return False + if self._edge_count != other._edge_count: + return False + if self._edges != other._edges: + return False + return True + + def __ne__(self, other): + return not self.__eq__(other) + + def __getitem__(self, item): + raise ValueError("Use g.node(n1) or g.edge(n1,n2)") + + def __setitem__(self, key, value): + raise ValueError("Use add_edge(node1, node2, value)") + + def __delitem__(self, key): + raise ValueError("Use del_edge(node1, node2)") + + def __contains__(self, item): + """ + :returns bool: True if node in Graph. + """ + return item in self._nodes + + def __len__(self): + raise ValueError("Use len(g.nodes()) or len(g.edges())") + + def copy(self): + cls = type(self) + g = cls() + for n in self._nodes: + g.add_node(n, obj=self._nodes[n]) + for s, e, d in self.edges(): + g.add_edge(s, e, d) + return g + + def add_edge(self, node1, node2, value=1, bidirectional=False): + """ + :param node1: hashable node + :param node2: hashable node + :param value: numeric value (int or float) + :param bidirectional: boolean. + """ + if isinstance(value, (dict, list, tuple)): + raise ValueError("value cannot be {}".format(type(value))) + if node1 not in self._nodes: + self.add_node(node1) + if node2 not in self._nodes: + self.add_node(node2) + + if node1 in self._edges and node2 in self._edges[node1]: # it's a value update. + self._edges[node1][node2] = value + self._reverse_edges[node2][node1] = value + else: # it's a new edge. + forward = self._edges.get(node1, None) + if forward is None: + self._edges[node1] = {node2: value} + else: + self._edges[node1][node2] = value + + rev = self._reverse_edges.get(node2,None) + if rev is None: + self._reverse_edges[node2] = {node1: value} + else: + self._reverse_edges[node2][node1] = value + + self._out_degree[node1] += 1 + self._in_degree[node2] += 1 + self._edge_count += 1 + + if bidirectional: + self.add_edge(node2, node1, value, bidirectional=False) + + def edge(self, node1, node2, default=None): + """Retrieves the edge (node1, node2) + Alias for g[node1][node2] + :param node1: node id + :param node2: node id + :param default: returned value if edge doesn't exist. + :return: edge(node1,node2) + """ + try: + return self._edges[node1][node2] + except KeyError: + return default + + def reverse_edge(self, node2, node1, default=None): + """retrieves the edge from node2 to node1""" + try: + return self._reverse_edges[node2][node1] + except KeyError: + return default + + def del_edge(self, node1, node2): + """ + removes edge from node1 to node2 + :param node1: node + :param node2: node + """ + try: + del self._edges[node1][node2] + except KeyError: + return + if not self._edges[node1]: + del self._edges[node1] + + del self._reverse_edges[node2][node1] + if not self._reverse_edges[node2]: + del self._reverse_edges[node2] + + self._out_degree[node1] -= 1 + self._in_degree[node2] -= 1 + self._edge_count -= 1 + + def add_node(self, node_id, obj=None): + """ + :param node_id: any hashable node. + :param obj: any object that the node should refer to. + PRO TIP: To retrieve the node obj use g.node(node_id) + """ + if node_id in self._nodes: # it's an object update. + self._nodes[node_id] = obj + else: + self._nodes[node_id] = obj + self._in_degree[node_id] = 0 + self._out_degree[node_id] = 0 + + def node(self, node_id): + """ + Retrieves the node object + :param node_id: id of node in graph. + :return: node object + """ + return self._nodes.get(node_id, None) + + def del_node(self, node_id): + """ + Deletes the node and all its connections. + :param node_id: node_id + :return: None + """ + if node_id not in self._nodes: + return + + # outgoing + if self._out_degree[node_id]!=0: + for n2, _ in self._edges[node_id].copy().items(): + self.del_edge(node_id, n2) + + # incoming + if self._in_degree[node_id]!=0: + for n1, _ in self._reverse_edges[node_id].copy().items(): + self.del_edge(n1, node_id) + + for _d in [ + self._edges, + self._reverse_edges, + self._nodes, + self._in_degree, + self._out_degree + ]: + try: + del _d[node_id] + except KeyError: + pass + + def nodes(self, from_node=None, to_node=None, in_degree=None, out_degree=None): + """ + :param from_node (optional) return nodes with edges from 'from_node' + :param to_node (optional) returns nodes with edges into 'to_node' + :param in_degree (optional) returns nodes with in_degree=N + :param out_degree (optional) returns nodes with out_degree=N + :return list of node ids. + """ + inputs = sum([1 for i in (from_node, to_node, in_degree, out_degree) if i is not None]) + if inputs > 1: + m = [] + a = (from_node, to_node, in_degree, out_degree) + b = ("from_node", "to_node", "in_degree", "out_degree") + for i in zip(a, b): + if i is not None: + m.append("{}={}".format(b, a)) + raise ValueError("nodes({}) has too many inputs. Pick one.".format(m)) + + if inputs == 0: + return list(self._nodes.keys()) + + if from_node is not None: + if from_node in self._edges: + return list(self._edges[from_node]) + return [] + + if to_node is not None: + return list(self._reverse_edges.get(to_node,{})) + + if in_degree is not None: + if not isinstance(in_degree, int) or in_degree < 0: + raise ValueError("in_degree must be int >= 0") + return [n for n, cnt in self._in_degree.items() if cnt == in_degree] + + if out_degree is not None: + if not isinstance(out_degree, int) or out_degree < 0: + raise ValueError("out_degree must be int >= 0") + return [n for n, cnt in self._out_degree.items() if cnt == out_degree] + + def edges(self, path=None, from_node=None, to_node=None): + """ + :param path (optional) list of nodes for which the edges are wanted. + :param from_node (optional) for which outgoing edges are returned. + :param to_node (optional) for which incoming edges are returned. + :return list of edges (n1, n2, value) + """ + inputs = sum([1 for i in (from_node, to_node, path) if i is not None]) + if inputs > 1: + m = [] + a = (path, from_node, to_node) + b = ("path", "from_node", "to_node") + for i in zip(a, b): + if i is not None: + m.append("{}={}".format(b, a)) + raise ValueError("edges({}) has too many inputs. Pick one.".format(m)) + + if path is not None: + if not isinstance(path, list): + raise ValueError("expects a list") + if len(path) < 2: + raise ValueError("path of length 1 is not a path.") + + return [(path[ix], path[ix + 1], self._edges[path[ix]][path[ix + 1]]) for ix in range(len(path) - 1)] + + if from_node is not None: + if from_node in self._edges: + return [(from_node, n2, cost) for n2, cost in self._edges[from_node].items()] + else: + return [] + + if to_node is not None: + if to_node in self._reverse_edges: + return [(n1, to_node, value) for n1, value in self._reverse_edges[to_node].items()] + else: + return [] + + return [(n1, n2, out[n2]) for n1, out in self._edges.items() for n2 in out] + + def from_dict(self, dictionary): + """ + Updates the graph from dictionary + :param dictionary: + d = {1: {2: 10, 3: 5}, + 2: {4: 1, 3: 2}, + 3: {2: 3, 4: 9, 5: 2}, + 4: {5: 4}, + 5: {1: 7, 4: 6}} + G = Graph(from_dict=d) + :return: None + """ + if not isinstance(dictionary, dict): + raise TypeError(f"expected dict, not {type(dictionary)}") + for n1, e in dictionary.items(): + if not e: + self.add_node(n1) + else: + for n2, v in e.items(): + self.add_edge(n1, n2, v) + + def to_dict(self): + """creates a nested dictionary from the graph. + :return dict d[n1][n2] = distance + """ + d = {n: {} for n in self.nodes()} + for n1, n2, dist in self.edges(): + d[n1][n2] = dist + return d + + def from_list(self, links): + """ + updates the graph from a list of links. + :param links: list + links = [ + (1, 2, 18), + (1, 3, 10), + (2, 4, 7), + (2, 5, 6), + (3, 4, 2), + (11,) # node with no links. + ] + """ + if not isinstance(links, Iterable): + raise TypeError(f"Expected iterable, not {type(links)}") + for item in links: + assert isinstance(item, (list, tuple)) + if len(item) > 1: + self.add_edge(*item) + else: + self.add_node(item[0]) + + def to_list(self): + """returns list of edges and nodes.""" + return self.edges() + [(i,) for i in self.nodes()] + + def is_connected(self, n1, n2): + """helper determining if two nodes are connected using BFS.""" + if n1 in self._edges: + q = deque([n1]) + visited = set() + while q: + n = q.popleft() + if n not in visited: + visited.add(n) + for c in self._edges.get(n,{}): + if c == n2: + return True # <-- Exit if connected. + if c in visited: + continue + else: + q.append(c) + return False # <-- Exit if not connected. + + def in_degree(self, node): + """returns the number of edges incoming on a node""" + return self._in_degree[node] + + def out_degree(self, node): + """returns the number of edges departing from a node""" + return self._out_degree[node] + + def distance(self, nodes, return_to_start=False): + length = sum(self.edge(nodes[i - 1], nodes[i]) for i in range(len(nodes))) + if return_to_start: + length += self.edge(nodes[-1], nodes[0]) + return length + # return sum(self.edge(n1, n2, default=float("inf")) for n1, n2 in zip(nodes[:-1], nodes[1:])) + + +def subgraph(graph, nodes): + """Creates a subgraph as a copy from the graph + :param graph: class Graph + :param nodes: set or list of nodes + :return: new instance of Graph. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + if not isinstance(nodes, (set, list)): + raise TypeError(f"expected nodes as a set or a list, not {type(nodes)}") + + node_set = set(nodes) + cls = type(graph) + g = cls() + for n1 in nodes: + obj = graph.node(n1) + g.add_node(n1, obj) + for n2 in graph.nodes(from_node=n1): + if n2 in node_set: + g.add_edge(n1, n2, graph.edge(n1, n2)) + return g + + +def is_subgraph(graph1, graph2): + """ + Checks if graph1 is subgraph in graph2 + :param graph1: instance of Graph + :param graph2: instance of Graph + :return: boolean + """ + if not isinstance(graph1, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph1)}") + if not isinstance(graph2, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph2)}") + + if not set(graph1.nodes()).issubset(set(graph2.nodes())): + return False + if not set(graph1.edges()).issubset(set(graph2.edges())): + return False + return True + + +def same_path(path1, path2): + """Compares two paths to verify whether they're the same despite being offset. + Very useful when comparing results from TSP as solutions may be rotations of + the same path. + :param path1: list of nodes. + :param path2: list of nodes. + :return: boolean. + """ + if not isinstance(path1, (list, set, tuple)): + raise TypeError(f"Expected path1 as Iterable, not {type(path1)}") + if not isinstance(path2, (list, set, tuple)): + raise TypeError(f"Expected path2 as Iterable, not {type(path2)}") + + if path1 is path2: # use id system to avoid work. + return True + if len(path1) != len(path2) or set(path1) != set(path2): + return False + + starts = (ix for ix, n2 in enumerate(path2) if path1[0] == n2) + return any(all(a == b for a, b in zip(path1, chain(path2[start:], path2[:start]))) for start in starts) + + +def has_path(graph, path): + """checks if path exists is graph + :param graph: instance of Graph + :param path: list of nodes + :return: boolean + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + if not isinstance(path, (list, tuple)): + raise TypeError(f"Expected list or tuple, not {type(path)}") + v1 = path[0] + for v2 in path[1:]: + if graph.edge(v1, v2) is None: + return False + else: + v1 = v2 + return True + + +def network_size(graph, n1, degrees_of_separation=None): + """Determines the nodes within the range given by + a degree of separation + :param graph: Graph + :param n1: start node + :param degrees_of_separation: integer + :return: set of nodes within given range + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + if n1 not in graph: + raise ValueError(f"{n1} not in graph") + + if degrees_of_separation is not None: + if not isinstance(degrees_of_separation, int): + raise TypeError(f"Expected degrees_of_separation to be integer, not {type(degrees_of_separation)}") + + network = {n1} + q = set(graph.nodes(from_node=n1)) + + scan_depth = 1 + while True: + if not q: # then there's no network. + break + + if degrees_of_separation is not None: + if scan_depth > degrees_of_separation: + break + + new_q = set() + for peer in q: + if peer in network: + continue + else: + network.add(peer) + new_peers = set(graph.nodes(from_node=peer)) - network + new_q.update(new_peers) + q = new_q + scan_depth += 1 + return network + + +def components(graph): + """Determines the components of the graph + :param graph: instance of class Graph + :return: list of sets of nodes. Each set is a component. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + + nodes = set(graph.nodes()) + sets_of_components = [] + while nodes: + new_component = set() + sets_of_components.append(new_component) + n = nodes.pop() # select random node + new_component.add(n) # add it to the new component. + + new_nodes = set(graph.nodes(from_node=n)) + new_nodes.update(set(graph.nodes(to_node=n))) + while new_nodes: + n = new_nodes.pop() + new_component.add(n) + new_nodes.update(set(n for n in graph.nodes(from_node=n) if n not in new_component)) + new_nodes.update(set(n for n in graph.nodes(to_node=n) if n not in new_component)) + nodes = nodes - new_component + return sets_of_components diff --git a/graph-theory/source/graph/bfs.py b/graph-theory/source/graph/bfs.py new file mode 100644 index 0000000000000000000000000000000000000000..fecb2604c4bbeefc3fc0ed8e63028acbbbfaf5c2 --- /dev/null +++ b/graph-theory/source/graph/bfs.py @@ -0,0 +1,67 @@ +from .base import BasicGraph + + +from collections import deque + + +def breadth_first_search(graph, start, end): + """Determines the path from start to end with fewest nodes. + :param graph: class Graph + :param start: start node + :param end: end node + :return: path + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + if start not in graph: + raise ValueError(f"{start} not in graph") + if end not in graph: + raise ValueError(f"{end} not in graph") + + visited = {start: None} + q = deque([start]) + while q: + node = q.popleft() + if node == end: + path = deque() + while node is not None: + path.appendleft(node) + node = visited[node] + return list(path) + for next_node in graph.nodes(from_node=node): + if next_node not in visited: + visited[next_node] = node + q.append(next_node) + return [] + + +def breadth_first_walk(graph, start, end=None, reversed_walk=False): + """ + :param graph: Graph + :param start: start node + :param end: end node. + :param reversed_walk: if True, the BFS traverse the graph backwards. + :return: generator for walk. + To walk all nodes use: `[n for n in g.breadth_first_walk(start)]` + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected BasicGraph, Graph or Graph3D, not {type(graph)}") + if start not in graph: + raise ValueError(f"{start} not in graph") + if end is not None and end not in graph: + raise ValueError(f"{end} not in graph. Use `end=None` if you want exhaustive search.") + if not isinstance(reversed_walk, bool): + raise TypeError(f"reversed_walk should be boolean, not {type(reversed_walk)}: {reversed_walk}") + + visited = {start: None} + q = deque([start]) + while q: + node = q.popleft() + yield node + if node == end: + break + L = graph.nodes(from_node=node) if not reversed_walk else graph.nodes(to_node=node) + for next_node in L: + if next_node not in visited: + visited[next_node] = node + q.append(next_node) \ No newline at end of file diff --git a/graph-theory/source/graph/core.py b/graph-theory/source/graph/core.py new file mode 100644 index 0000000000000000000000000000000000000000..f3ec8039a765064c397df5614c560a1875d10822 --- /dev/null +++ b/graph-theory/source/graph/core.py @@ -0,0 +1,404 @@ +from .base import BasicGraph, subgraph, is_subgraph, same_path, has_path, network_size, components +from .adjacency_matrix import adjacency_matrix +from .all_pairs_shortest_path import all_pairs_shortest_paths +from .all_paths import all_paths +from .all_simple_paths import all_simple_paths +from .bfs import breadth_first_search, breadth_first_walk +from .critical_path import critical_path_minimize_for_slack, critical_path +from .cycle import cycle, has_cycles +from .dag import phase_lines, sources +from .degree_of_separation import degree_of_separation +from .dfs import depth_first_search, depth_scan +from .distance_map import distance_map +from .max_flow import maximum_flow +from .max_flow_min_cut import maximum_flow_min_cut +from .min_cost_flow import minimum_cost_flow_using_successive_shortest_path +from .minmax import minmax +from .minsum import minsum +from .partite import is_partite +from .shortest_path import shortest_path, shortest_path_bidirectional, ShortestPathCache, distance_from_path +from .shortest_tree_all_pairs import shortest_tree_all_pairs +from .topological_sort import topological_sort +from .tsp import tsp_branch_and_bound, tsp_greedy, tsp_2023 + + +__description__ = """ +The graph-theory library is organised in the following way for clarity of structure: + +1. BasicGraph (class) - with general methods for all subclasses. +2. All methods for class Graph in same order as on Graph. +3. Graph (class) +4. Graph3D (class) +""" + + +class Graph(BasicGraph): + """ + Graph is the base graph that all methods use. + + For methods, please see the documentation on the + individual functions, by importing them separately. + + """ + + def __init__(self, from_dict=None, from_list=None): + super().__init__(from_dict=from_dict, from_list=from_list) + self._cache = None + + def shortest_path(self, start, end, memoize=False, avoids=None): + """ + :param start: start node + :param end: end node + :param memoize: boolean (stores paths in a cache for faster repeated lookup) + :param avoids: optional. A frozen set of nodes that cannot be on the path. + :return: distance, path as list + """ + if not memoize: + return shortest_path(graph=self, start=start, end=end, avoids=avoids) + + if self._cache is None: + self._cache = ShortestPathCache(graph=self) + return self._cache.shortest_path(start, end, avoids=avoids) + + def shortest_path_bidirectional(self, start, end): + """ + :param start: start node + :param end: end node + :return: distance, path as list + """ + return shortest_path_bidirectional(self, start, end) + + def breadth_first_search(self, start, end): + """Determines the path with fewest nodes. + :param start: start node + :param end: end nodes + :return: nodes, path as list + """ + return breadth_first_search(graph=self, start=start, end=end) + + def breadth_first_walk(self, start, end=None, reversed_walk=False): + """ + :param start: start node + :param end: end node + :param reversed_walk: if True, the BFS walk is backwards. + :return: generator for breadth-first walk + """ + return breadth_first_walk(graph=self, start=start, end=end, reversed_walk=reversed_walk) + + def distance_map(self, starts=None, ends=None, reverse=False): + """Maps the shortest path distance from any start to any end. + :param graph: instance of Graph + :param starts: node or (set,list,tuple) of nodes + :param ends: None (exhaustive map), node or (set,list,tuple) of nodes + :param reverse: boolean, if True follows edges backwards. + :return: dictionary with {node: distance from start} + """ + return distance_map(self, starts, ends, reverse) + + def depth_first_search(self, start, end): + """ + Finds a path from start to end using DFS. + :param start: start node + :param end: end node + :return: path + """ + return depth_first_search(graph=self, start=start, end=end) + + def depth_scan(self, start, criteria): + """ + traverses the descendants of node `start` using callable `criteria` to determine + whether to terminate search along each branch in `graph`. + + :param start: start node + :param criteria: function to terminate scan along a branch must return bool + :return: set of nodes + """ + return depth_scan(graph=self, start=start, criteria=criteria) + + def distance_from_path(self, path): + """ + :param path: list of nodes + :return: distance along the path. + """ + return distance_from_path(graph=self, path=path) + + def maximum_flow(self, start, end): + """Determines the maximum flow of the graph between + start and end. + :param start: node (source) + :param end: node (sink) + :return: flow, graph of flow. + """ + return maximum_flow(self, start, end) + + def maximum_flow_min_cut(self, start, end): + """ + Finds the edges in the maximum flow min cut. + :param start: start + :param end: end + :return: list of edges + """ + return maximum_flow_min_cut(self, start, end) + + def minimum_cost_flow(self, inventory, capacity=None): + """ + :param self: Graph with `cost per unit` as edge + :param inventory: dict {node: stock, ...} + stock < 0 is demand + stock > 0 is supply + :param capacity: None or Graph with `capacity` as edge. + :return: total costs, graph of flows in solution. + """ + return minimum_cost_flow_using_successive_shortest_path(self, inventory, capacity) + + def solve_tsp(self, method="2023"): + """solves the traveling salesman problem for the graph + (finds the shortest path through all nodes) + + :param method: str: 'greedy' + + options: + 'greedy' see tsp_greedy + 'bnb' see tsp_branch_and_bound + + :return: tour length (path+return to starting point), + path travelled. + """ + methods = {"greedy": tsp_greedy, "bnb": tsp_branch_and_bound, "2023": tsp_2023} + solver = methods.get(method) + return solver(self) + + def subgraph_from_nodes(self, nodes): + """ + constructs a copy of the graph containing only the + listed nodes (and their links) + :param nodes: list of nodes + :return: class Graph + """ + return subgraph(graph=self, nodes=nodes) + + def is_subgraph(self, other): + """Checks if self is a subgraph in other. + :param other: instance of Graph + :return: boolean + """ + return is_subgraph(self, other) + + def is_partite(self, n=2): + """Checks if self is n-partite + :param n: int the number of partitions. + :return: tuple: boolean, partitions as dict + (or None if graph isn't n-partite) + """ + return is_partite(self, n) + + def has_cycles(self): + """Checks if the graph has a cycle + :return: bool + """ + return has_cycles(graph=self) + + def components(self): + """Determines the number of components + :return: list of sets of nodes. Each set is a component. + """ + return components(graph=self) + + def network_size(self, n1, degrees_of_separation=None): + """Determines the nodes within the range given by + a degree of separation + :param n1: start node + :param degrees_of_separation: integer + :return: set of nodes within given range + """ + return network_size(self, n1, degrees_of_separation) + + def phase_lines(self): + """Determines the phase lines (cuts) of the graph + :returns: dictionary with phase: nodes in phase + """ + return phase_lines(self) + + def sources(self, n): + """Determines the DAG sources of node n""" + return sources(graph=self, n=n) + + def topological_sort(self, key=None): + """Returns a generator for the topological order""" + return topological_sort(self, key=key) + + def critical_path(self): + f"""{critical_path.__doc__}""" + return critical_path(self) + + def critical_path_minimize_for_slack(self): + f"""{critical_path_minimize_for_slack.__doc__}""" + return critical_path_minimize_for_slack(self) + + @staticmethod + def same_path(p1, p2): + """compares two paths to determine if they're the same, despite + being in different order. + + :param p1: list of nodes + :param p2: list of nodes + :return: boolean + """ + return same_path(p1, p2) + + def adjacency_matrix(self): + """ + Converts directed graph to an adjacency matrix. + Note: The distance from a node to itself is 0 and distance from a node to + an unconnected node is defined to be infinite. This does not mean that there + is no path from a node to another via other nodes. + :return: dict + """ + return adjacency_matrix(graph=self) + + def minsum(self): + """Finds the mode(s) that have the smallest sum of distance to all other nodes. + :return: list of nodes + """ + return minsum(self) + + def minmax(self): + """Finds the node(s) with shortest distance to all other nodes. + :return: list of nodes + """ + return minmax(self) + + def all_pairs_shortest_paths(self): + """ + Find the cost of the shortest path between every pair of vertices in a + weighted graph. Uses the Floyd-Warshall algorithm. + :return: dict {node 1: {node 2: distance}, ...} + """ + return all_pairs_shortest_paths(graph=self) + + def shortest_tree_all_pairs(self): + """ + :return: + """ + return shortest_tree_all_pairs(graph=self) + + def has_path(self, path): + """ + :param path: list of nodes + :return: boolean, if the path is in G. + """ + return has_path(graph=self, path=path) + + def all_simple_paths(self, start, end): + """ + finds all simple (non-looping) paths from start to end + :param start: node + :param end: node + :return: list of paths + """ + return all_simple_paths(self, start, end) + + def all_paths(self, start, end): + """finds all paths from start to end by traversing each fork once only. + :param start: node + :param end: node + :return: list of paths + """ + return all_paths(graph=self, start=start, end=end) + + def degree_of_separation(self, n1, n2): + """determines the degree of separation between 2 nodes + :param n1: node + :param n2: node + :return: degree + """ + return degree_of_separation(self, n1, n2) + + def loop(self, start, mid, end=None): + """finds a looped path via a mid-point + :param start: node + :param mid: node, midpoint for loop. + :param end: node + :return: path as list + """ + return cycle(self, start, mid, end) + + +class Graph3D(Graph): + """a graph where all (x,y)-positions are unique.""" + + def __init__(self, from_dict=None, from_list=None): + super().__init__(from_dict=from_dict, from_list=from_list) + + def copy(self): + g = Graph3D(from_dict=self.to_dict()) + return g + + # spatial only function + # --------------------- + @staticmethod + def _check_tuples(n1): + if not isinstance(n1, tuple): + raise TypeError(f"expected tuple, not {type(n1)}") + if len(n1) != 3: + raise ValueError(f"expected tuple in the form as (x,y,z), got {n1}") + if not all(isinstance(i, (float, int)) for i in n1): + raise TypeError(f"expected all values to be integer or float, but got {n1}") + + @staticmethod + def distance(n1, n2): + """returns the distance between to xyz tuples coordinates + :param n1: (x,y,z) + :param n2: (x,y,z) + :return: float + """ + Graph3D._check_tuples(n1) + Graph3D._check_tuples(n2) + (x1, y1, z1), (x2, y2, z2) = n1, n2 + a = abs(x2 - x1) + b = abs(y2 - y1) + c = abs(z2 - z1) + return (a * a + b * b + c * c) ** (1 / 2) + + def add_edge(self, n1, n2, value=None, bidirectional=False): + self._check_tuples(n1) + self._check_tuples(n2) + assert value is not None + super().add_edge(n1, n2, value, bidirectional) + + def add_node(self, node_id, obj=None): + self._check_tuples(node_id) + super().add_node(node_id, obj) + """ + :param node_id: any hashable node. + :param obj: any object that the node should refer to. + + PRO TIP: To retrieve the node obj use g.node(node_id) + """ + self._nodes[node_id] = obj + + def n_nearest_neighbours(self, node_id, n=1): + """returns the node id of the `n` nearest neighbours.""" + self._check_tuples(node_id) + if not isinstance(n, int): + raise TypeError(f"expected n to be integer, not {type(n)}") + if n < 1: + raise ValueError(f"expected n >= 1, not {n}") + + d = [(self.distance(n1=node_id, n2=n), n) for n in self.nodes() if n != node_id] + d.sort() + if d: + return [b for a, b in d][:n] + return None + + def plot(self, nodes=True, edges=True, rotation="xyz", maintain_aspect_ratio=False): + """plots nodes and links using matplotlib3 + :param nodes: bool: plots nodes + :param edges: bool: plots edges + :param rotation: str: set view point as one of [xyz,xzy,yxz,yzx,zxy,zyx] + :param maintain_aspect_ratio: bool: rescales the chart to maintain aspect ratio. + :return: None. Plots figure. + """ + from graph.visuals import plot_3d # noqa + + return plot_3d(self, nodes, edges, rotation, maintain_aspect_ratio) diff --git a/graph-theory/source/graph/critical_path.py b/graph-theory/source/graph/critical_path.py new file mode 100644 index 0000000000000000000000000000000000000000..18ea0910cff58f56e8513c7e6c66f2bf811f5c31 --- /dev/null +++ b/graph-theory/source/graph/critical_path.py @@ -0,0 +1,197 @@ +from .base import BasicGraph +from .dag import phase_lines +from .topological_sort import topological_sort + + +class Task(object): + """Helper for critical path method""" + + __slots__ = ["task_id", "duration", "earliest_start", "earliest_finish", "latest_start", "latest_finish"] + + def __init__( + self, + task_id, + duration, + earliest_start=0, + latest_start=0, + earliest_finish=float("inf"), + latest_finish=float("inf"), + ): + self.task_id = task_id + self.duration = duration + self.earliest_start = earliest_start + self.latest_start = latest_start + self.earliest_finish = earliest_finish + self.latest_finish = latest_finish + + def __eq__(self, other): + if not isinstance(other, Task): + raise TypeError(f"can't compare {type(other)} with {type(self)}") + if any( + ( + self.task_id != other.task_id, + self.duration != other.duration, + self.earliest_start != other.earliest_start, + self.latest_start != other.latest_start, + self.earliest_finish != other.earliest_finish, + self.latest_finish != other.latest_finish, + ) + ): + return False + return True + + @property + def slack(self): + return self.latest_finish - self.earliest_finish + + @property + def args(self): + return ( + self.task_id, + self.duration, + self.earliest_start, + self.latest_start, + self.earliest_finish, + self.latest_finish, + ) + + def __repr__(self): + return f"{self.__class__.__name__}{self.args}" + + def __str__(self): + return self.__repr__() + + +def critical_path(graph): + """ + The critical path method determines the + schedule of a set of project activities that results in + the shortest overall path. + :param graph: acyclic graph where: + nodes are task_id and node_obj is a value + edges determines dependencies + (see example below) + :return: critical path length, schedule. + schedule is list of Tasks + Recipes: + (1) Setting up the graph: + tasks = {'A': 10, 'B': 20, 'C': 5, 'D': 10, 'E': 20, 'F': 15, 'G': 5, 'H': 15} + dependencies = [ + ('A', 'B'), + ('B', 'C'), + ('C', 'D'), + ('D', 'E'), + ('A', 'F'), + ('F', 'G'), + ('G', 'E'), + ('A', 'H'), + ('H', 'E'), + ] + g = Graph() + for task, duration in tasks.items(): + g.add_node(task, obj=duration) + for n1, n2 in dependencies: + g.add_edge(n1, n2, 0) + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + # 1. A topologically sorted list of nodes is prepared (topo.order). + order = list(topological_sort(graph)) # this will raise if there are loops. + + d = {} + critical_path_length = 0 + + for task_id in order: # 2. forward pass: + predecessors = [d[t] for t in graph.nodes(to_node=task_id)] + duration = graph.node(task_id) + if not isinstance(duration, (float, int)): + raise ValueError(f"Expected task {task_id} to have a numeric duration, but got {type(duration)}") + t = Task(task_id=task_id, duration=duration) + # 1. the earliest start and earliest finish is determined in topological order. + t.earliest_start = max(t.earliest_finish for t in predecessors) if predecessors else 0 + t.earliest_finish = t.earliest_start + t.duration + d[task_id] = t + # 2. the path length is recorded. + critical_path_length = max(t.earliest_finish, critical_path_length) + + for task_id in reversed(order): # 3. backward pass: + successors = [d[t] for t in graph.nodes(from_node=task_id)] + t = d[task_id] + # 1. the latest start and finish is determined in reverse topological order + t.latest_finish = min(t.latest_start for t in successors) if successors else critical_path_length + t.latest_start = t.latest_finish - t.duration + + return critical_path_length, d + + +def critical_path_minimize_for_slack(graph): + """ + Determines the critical path schedule and attempts to minimise + the concurrent resource requirements by inserting the minimal + number of artificial dependencies. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + cpl, schedule = critical_path(graph) + phases = phase_lines(graph) + + new_graph = graph.copy() + slack_nodes = [t for k, t in schedule.items() if t.slack > 0] # slack == 0 is on the critical path. + slack_nodes.sort(reverse=True, key=lambda t: t.slack) # most slack on top as it has more freedom to move. + slack_node_ids = [t.task_id for t in slack_nodes] + slack = sum(t.slack for t in schedule.values()) + + # Part 1. Use a greedy algorithm to determine an initial solution. + new_edges = [] + stop = False + for node in sorted(slack_nodes, reverse=True, key=lambda t: t.duration): + if stop: + break + # identify any option for insertion: + n1 = node.task_id + for n2 in ( + n2 + for n2 in slack_node_ids + if n2 != n1 # ...not on critical path + and phases[n2] >= phases[n1] # ...not pointing to the source + and new_graph.edge(n2, n1) is None # ...downstream + and new_graph.edge(n1, n2) is None # ... not creating a cycle. + ): # ... not already a dependency. + new_graph.add_edge(n1, n2) + new_edges.append((n1, n2)) + + cpl2, schedule2 = critical_path(new_graph) + if cpl2 != cpl: # the critical path is not allowed to be longer. Abort. + new_graph.del_edge(n1, n2) + new_edges.remove((n1, n2)) + continue + + slack2 = sum(t.slack for t in schedule2.values()) + + if slack2 < slack and cpl == cpl2: # retain solution! + slack = slack2 + if slack == 0: # an optimal solution has been found! + stop = True + break + else: + new_graph.del_edge(n1, n2) + new_edges.remove((n1, n2)) + + # Part 2. Purge non-effective edges. + for edge in new_graph.edges(): + n1, n2, _ = edge + if graph.edge(n1, n2) is not None: + continue # it's an original edge. + # else: it's an artificial edge: + new_graph.del_edge(n1, n2) + cpl2, schedule2 = critical_path(new_graph) + slack2 = sum(t.slack for t in schedule2.values()) + + if cpl2 == cpl and slack2 == slack: + continue # the removed edge had no effect and just made the graph more complicated. + else: + new_graph.add_edge(n1, n2) + + return new_graph \ No newline at end of file diff --git a/graph-theory/source/graph/cycle.py b/graph-theory/source/graph/cycle.py new file mode 100644 index 0000000000000000000000000000000000000000..d901a732b2cbe677f772384194293ac36fa4a603 --- /dev/null +++ b/graph-theory/source/graph/cycle.py @@ -0,0 +1,46 @@ +from .base import BasicGraph +from .topological_sort import topological_sort + + +def cycle(graph, start, mid, end=None): + """Returns a loop passing through a defined mid-point and returning via a different set of nodes to the outward + journey. If end is None we return to the start position.""" + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError("start not in graph.") + if mid not in graph: + raise ValueError("mid not in graph.") + if end is not None and end not in graph: + raise ValueError("end not in graph.") + + _, p = graph.shortest_path(start, mid) + g2 = graph.copy() + if end is not None: + for n in p[:-1]: + g2.del_node(n) + _, p2 = g2.shortest_path(mid, end) + else: + for n in p[1:-1]: + g2.del_node(n) + _, p2 = g2.shortest_path(mid, start) + lp = p + p2[1:] + return lp + + +def has_cycles(graph): + """Checks if graph has a cycle + :param graph: instance of class Graph. + :return: bool + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + for n1, n2, _ in graph.edges(): + if n1 == n2: # detect nodes that point to themselves + return True + try: + _ = list(topological_sort(graph)) # tries to create a DAG. + return False + except AttributeError: + return True \ No newline at end of file diff --git a/graph-theory/source/graph/dag.py b/graph-theory/source/graph/dag.py new file mode 100644 index 0000000000000000000000000000000000000000..94f2afc8bc853a347a7690b37f4d0c8db7d837bb --- /dev/null +++ b/graph-theory/source/graph/dag.py @@ -0,0 +1,113 @@ +from collections import deque +from .base import BasicGraph + + +def phase_lines(graph): + """Determines the phase lines of a directed graph. + This is useful for determining which tasks can be performed in + parallel. Each phase in the phaselines must be completed to assure + that the tasks in the next phase can be performed with complete input. + This is in contrast to Topological sort that only generates + a queue of tasks, may be fine for a single processor, but has no + mechanism for coordination that all inputs for a task have been completed + so that multiple processors can work on them. + Example: DAG with tasks: + u1 u4 u2 u3 + | | |_______| + csg cs3 append + | | | + op1 | op3 + | | | + op2 | cs2 + | |___________| + cs1 join + | | + map1 map2 + |___________| + save + phaselines = { + "u1": 0, "u4": 0, "u2": 0, "u3": 0, + "csg": 1, "cs3": 1, "append": 1, + "op1": 2, "op3": 2, "op2": 3, "cs2": 3, + "cs1": 4, "join": 4, + "map1": 5, "map2": 5, + "save": 6, + } + From this example it is visible that processing the 4 'uN' (uploads) is + the highest degree of concurrency. This can be determined as follows: + d = defaultdict(int) + for _, pl in graph.phaselines(): + d[pl] += 1 + max_processors = max(d, key=d.get) + :param graph: Graph + :return: dictionary with node id : phase in cut. + Note: To transform the phaselines into a task sequence use + the following recipe: + tasks = defaultdict(set) + for node, phase in phaselines(graph): + tasks[phase].add(node) + To obtain a sort stable tasks sequence use: + for phase in sorted(tasks): + print(phase, list(sorted(tasks[phase])) + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + nmax = len(graph.nodes()) + phases = {n: nmax + 1 for n in graph.nodes()} + phase_counter = 0 + + g2 = graph.copy() + q = list(g2.nodes(in_degree=0)) # Current iterations work queue + if not q: + raise AttributeError("The graph does not have any sources.") + + q2 = set() # Next iterations work queue + while q: + for n1 in q: + if g2.in_degree(n1)!=0: + q2.add(n1) # n1 has an in coming edge, so it has to wait. + continue + phases[n1] = phase_counter # update the phaseline number + for n2 in g2.nodes(from_node=n1): + q2.add(n2) # add node for next iteration + + # at this point the nodes with no incoming edges have been accounted + # for, so now they may be removed for the working graph. + for n1 in q: + if n1 not in q2: + g2.del_node(n1) # remove nodes that have no incoming edges + + if set(q) == q2: + raise AttributeError("Loop found: The graph is not acyclic!") + + # Finally turn the next iterations workqueue into current. + # and increment the phaseline counter. + q = [n for n in q2] + q2.clear() + phase_counter += 1 + return phases + + +def sources(graph, n): + """Determines the set of all upstream sources of node 'n' in a DAG. + :param graph: Graph + :param n: node for which the sources are sought. + :return: set of nodes + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if n not in graph: + raise ValueError(f"{n} not in graph") + + nodes = {n} + q = deque([n]) + while q: + new = q.popleft() + for src in graph.nodes(to_node=new): + if src not in nodes: + nodes.add(src) + if src not in q: + q.append(src) + nodes.remove(n) + return nodes diff --git a/graph-theory/source/graph/degree_of_separation.py b/graph-theory/source/graph/degree_of_separation.py new file mode 100644 index 0000000000000000000000000000000000000000..6ea18b0c4bf42ec5f6c79ef05761ef7a12c0fc80 --- /dev/null +++ b/graph-theory/source/graph/degree_of_separation.py @@ -0,0 +1,16 @@ +from .base import BasicGraph +from .bfs import breadth_first_search + + +def degree_of_separation(graph, n1, n2): + """Calculates the degree of separation between 2 nodes.""" + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if n1 not in graph: + raise ValueError("n1 not in graph.") + if n2 not in graph: + raise ValueError("n2 not in graph.") + + assert n1 in graph.nodes() + p = breadth_first_search(graph, n1, n2) + return len(p) - 1 \ No newline at end of file diff --git a/graph-theory/source/graph/dfs.py b/graph-theory/source/graph/dfs.py new file mode 100644 index 0000000000000000000000000000000000000000..803678818a1ecc8b2b3f9bbdc32218ce43331b8f --- /dev/null +++ b/graph-theory/source/graph/dfs.py @@ -0,0 +1,97 @@ +from .base import BasicGraph + + +from collections import deque + + +def depth_first_search(graph, start, end): + """ + Determines path from start to end using + 'depth first search' with backtracking. + :param graph: class Graph + :param start: start node + :param end: end node + :return: path as list of nodes. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError(f"{start} not in graph") + if end not in graph: + raise ValueError(f"{end} not in graph") + + q = deque([start]) # q = [start] + # using deque as popleft and appendleft is faster than using lists. For details see + # https://stackoverflow.com/questions/23487307/python-deque-vs-list-performance-comparison + path = [] + visited = set() + while q: + n1 = q.popleft() # n1 = q.pop() + visited.add(n1) + path.append(n1) + if n1 == end: + return path # <-- exit if end is found. + for n2 in graph.nodes(from_node=n1): + if n2 in visited: + continue + q.appendleft(n2) # q.append(n2) + break + else: + path.remove(n1) + while not q and path: + for n2 in graph.nodes(from_node=path[-1]): + if n2 in visited: + continue + q.appendleft(n2) # q.append(n2) + break + else: + path = path[:-1] + return None # <-- exit if not path was found. + + +def depth_scan(graph, start, criteria): + """traverses the descendants of node `start` using callable `criteria` to determine + whether to terminate search along each branch in `graph`. + :param graph: class Graph + :param start: start node + :param criteria: function to terminate scan along a branch must return bool + :return: set of nodes + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError(f"{start} not in graph") + if not callable(criteria): + raise TypeError(f"Expected {criteria} to be callable") + if not criteria(start): + return set() + + q = [start] + path = [] + visited = set() + while q: + n1 = q.pop() + visited.add(n1) + path.append(n1) + for n2 in graph.nodes(from_node=n1): + if n2 in visited: + continue + if not criteria(n2): + visited.add(n2) + continue + q.append(n2) + break + else: + path.remove(n1) + while not q and path: + for n2 in graph.nodes(from_node=path[-1]): + if n2 in visited: + continue + if not criteria(n2): + visited.add(n2) + continue + q.append(n2) + break + else: + path = path[:-1] + return visited \ No newline at end of file diff --git a/graph-theory/source/graph/distance_map.py b/graph-theory/source/graph/distance_map.py new file mode 100644 index 0000000000000000000000000000000000000000..60612fb1b88d42e444e2d245077793bf0cc862da --- /dev/null +++ b/graph-theory/source/graph/distance_map.py @@ -0,0 +1,78 @@ +from .base import BasicGraph + + +from collections import deque +from collections.abc import Iterable + + +def distance_map(graph, starts=None, ends=None, reverse=False): + """Maps the shortest path distance from any start to any end. + :param graph: instance of Graph + :param starts: None, node or (set,list,tuple) of nodes + :param ends: None (exhaustive map), node or (set,list,tuple) of nodes + that terminate the search when all are found + :param reverse: bool: walks the map from the ends towards the starts using reversed edges. + :return: dictionary with {node: distance from start} + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + if not isinstance(reverse, bool): + raise TypeError("keyword reverse was not boolean") + + if all((starts is None, ends is None)): + raise ValueError("starts and ends cannot both be None") + if all((starts is None, reverse is False)): + raise ValueError("walking forward from end doesn't make sense.") + if all((ends is None, reverse is True)): + raise ValueError("walking from reverse from start doesn't make sense.") + + if isinstance(starts, Iterable): + starts = set(starts) + else: + starts = {starts} + if any(start not in graph for start in starts if start is not None): + missing = [start not in graph for start in starts] + raise ValueError(f"starts: ({missing}) not in graph") + + if isinstance(ends, Iterable): + ends = set(ends) + else: + ends = {ends} + if any(end not in graph for end in ends if end is not None): + missing = [end not in graph for end in ends if end is not None] + raise ValueError(f"{missing} not in graph. Use `end=None` if you want exhaustive search.") + + if not reverse: + ends_found = set() + visited = {start: 0 for start in starts} + q = deque(starts) + while q: + if ends_found == ends: + break + n1 = q.popleft() + if n1 in ends: + ends_found.add(n1) + d1 = visited[n1] + for _, n2, d in graph.edges(from_node=n1): + if n2 not in visited: + q.append(n2) + visited[n2] = min(d1 + d, visited.get(n2, float("inf"))) + + else: + starts_found = set() + visited = {end: 0 for end in ends} + q = deque(ends) + while q: + if starts_found == starts: + break + n2 = q.popleft() + if n2 in starts: + starts_found.add(n2) + d2 = visited[n2] + for n1, _, d in graph.edges(to_node=n2): + if n1 not in visited: + q.append(n1) + visited[n1] = min(d + d2, visited.get(n1, float("inf"))) + + return visited \ No newline at end of file diff --git a/graph-theory/source/graph/finite_state_machine.py b/graph-theory/source/graph/finite_state_machine.py new file mode 100644 index 0000000000000000000000000000000000000000..067bfc8934ab5ec0b03b61bbdbe14f05829926b0 --- /dev/null +++ b/graph-theory/source/graph/finite_state_machine.py @@ -0,0 +1,60 @@ +from .base import BasicGraph +from itertools import count + + +class FiniteStateMachine(object): + def __init__(self): + self.states = BasicGraph() + self.current_state = None + self._action_id = count() + self.actions = {} + self._initial_state_was_set = False + + def set_initial_state(self, state): + """ method for setting initial state of the FSM + + :param state: available in options + :return: None + """ + if self._initial_state_was_set: + raise ValueError("initial state has already been set.") + if state not in self.states.nodes(): + raise ValueError(f"{state} is not a state.") + self.current_state = state + self._initial_state_was_set = True + + def add_transition(self, state_1, action, state_2): + """ Adds a state transition from state 1 to state 2 if action is performed. + + :param state_1: any hashable value. + :param action: any hashable value. + :param state_2: any hashable value. + :return: None + """ + action_id = next(self._action_id) + self.states.add_edge(node1=state_1, node2=action_id) + self.states.add_edge(node1=action_id, node2=state_2) + self.actions[action_id] = action + + def options(self): + """ returns list of options for the FSMs current state. """ + return [self.actions[i] for i in self.states.nodes(from_node=self.current_state)] + + def next(self, action): + """ transitions the FSM from it's current state as a reaction to input `action`. + + :param action: any action available in fsm.options() + :return: None + """ + if self._initial_state_was_set is False: + raise ValueError("initial state has not been set.") + actions = self.states.nodes(from_node=self.current_state) + if not actions: + raise StopIteration("terminal node reached.") + + for action_id in actions: + if self.actions[action_id] == action: + self.current_state = self.states.nodes(from_node=action_id)[0] + return + raise ValueError(f"{self.current_state} does not permit {action}.") + diff --git a/graph-theory/source/graph/hash_methods.py b/graph-theory/source/graph/hash_methods.py new file mode 100644 index 0000000000000000000000000000000000000000..1f758f98dae9b31d192f5ff944637893bb19b050 --- /dev/null +++ b/graph-theory/source/graph/hash_methods.py @@ -0,0 +1,133 @@ +import hashlib + +from .base import BasicGraph + + +def graph_hash(graph): + """ Generates the top hash of the graph using sha3_256. + :param graph: instance of class Graph. + :return: graph hash (int) and graph (Graph) with hash values + """ + assert isinstance(graph, BasicGraph) + hash_func = hashlib.sha3_256() + nodes = bytes("|".join(str(n) for n in sorted(graph.nodes())), 'utf-8') + edges = bytes("|".join(str(e) for e in sorted(graph.edges())), 'utf-8') + hash_func.update(nodes + edges) + return int(hash_func.hexdigest(), 16) + + +def flow_graph_hash(graph): + """ + Calculates the hash of a flow graph, where the properties of the nodes + and the supplying nodes are included in the hash. + + Any upstream change in hash will thereby propagate downstream. + """ + assert isinstance(graph, BasicGraph) + sources = graph.nodes(in_degree=0) + + original_hash = 'original hash' + new_hash = 'new_hash' + cls = type(graph) + hash_graph = cls() # new graph with hashes. + visited = set() + + while sources: + source = sources[0] + sources = sources[1:] + + suppliers = graph.nodes(to_node=source) + + hash_func = hashlib.sha3_256() + hash_func.update(bytes(str(source), 'utf-8')) + for supplier in suppliers: + if graph.depth_first_search(start=source, end=supplier): + continue # it's a cycle. + d = hash_graph.node(supplier) + hash_func.update(bytes(d[new_hash], 'utf-8')) + source_hash = hash_func.hexdigest() + + if source not in hash_graph: + obj = {original_hash: source, new_hash: source_hash} + hash_graph.add_node(source, obj=obj) + else: + n = hash_graph.node(source) + n[new_hash] = source_hash + + receivers = graph.nodes(from_node=source) + for receiver in receivers: + if receiver in visited: + continue + visited.add(receiver) + + if receiver not in hash_graph: + obj = {original_hash: receiver, new_hash: None} + hash_graph.add_node(node_id=receiver, obj=obj) + hash_graph.add_edge(source, receiver) + if receiver not in sources: + sources.append(receiver) + + for sink in graph.nodes(out_degree=0): + n = hash_graph.node(sink) + assert n[new_hash] is not None, n + + return hash_graph + + +def merkle_tree(data_blocks): + """ + A hash tree or Merkle tree is a tree in which every leaf node is labelled with + the hash of a data block, and every non-leaf node is labelled with the + cryptographic hash of the labels of its child nodes. Hash trees allow efficient + and secure verification of the contents of large data structures. Hash trees + are a generalization of hash lists and hash chains. + + Top Hash + hash ( 0 + 1 ) + ^ ^ + | | + +-------> +---------+ + ^ ^ + | | + + + + Hash 0 Hash 1 + hash ( 0-0 + 0-1 ) hash ( 1-0 + 1-1 ) + ^ ^ ^ ^ + | | | | + + + + + + Hash 0-0 Hash 0-1 Hash 1-0 Hash 1-1 + hash(L1) hash(L2) hash(L3) hash(L4) + ^ ^ ^ ^ + | | | | + +----------------------------------------------+ + | L1 L2 L3 L4 | Data blocks + +----------------------------------------------+ + + """ + g = BasicGraph() + + # initial hash: + leaves = [] + for block in data_blocks: + assert isinstance(block, bytes) + hash_func = hashlib.sha3_256() + hash_func.update(block) + uuid = hash_func.hexdigest() + leaves.append(uuid) + g.add_node(node_id=uuid) + + # populate graph + while leaves: + if len(leaves) == 1: + return g # <--- point of return. + + c1, c2 = leaves[:2] + leaves = leaves[2:] + + hash_func = hashlib.sha3_256() + hash_func.update(bytes(c1, 'utf-8') + bytes(c2, 'utf-8')) + uuid = hash_func.hexdigest() + leaves.append(uuid) + g.add_node(node_id=uuid) + g.add_edge(c1, uuid) + g.add_edge(c2, uuid) \ No newline at end of file diff --git a/graph-theory/source/graph/max_flow.py b/graph-theory/source/graph/max_flow.py new file mode 100644 index 0000000000000000000000000000000000000000..84dc920d49269de7ab7c3f926938dfdec1839f70 --- /dev/null +++ b/graph-theory/source/graph/max_flow.py @@ -0,0 +1,87 @@ +from .base import BasicGraph +from .shortest_path import shortest_path + + +def maximum_flow(graph, start, end): + """ + Returns the maximum flow graph + :param graph: instance of Graph + :param start: node + :param end: node + :return: flow, graph + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + Graph = type(graph) + + if start not in graph: + raise ValueError(f"{start} not in graph") + if end not in graph: + raise ValueError(f"{end} not in graph") + + inflow = sum(d for s, e, d in graph.edges(from_node=start)) + outflow = sum(d for s, e, d in graph.edges(to_node=end)) + unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time. + total_flow = 0 + # ----------------------------------------------------------------------- + # The algorithm + # I reviewed a number of algorithms, such as Ford-fulkerson algorithm, + # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage + # of DFS, which leads to a lot of node visits. + # + # I therefore choose to invert the capacities of the graph so that the + # capacity any G[u][v] = c becomes 1/c in G_inverted. + # This allows me to use the shortest path method to find the path with + # most capacity in the first attempt, resulting in a significant reduction + # of unassigned flow. + # + # By updating G_inverted, with the residual capacity, I can keep using the + # shortest path, until the capacity is zero, whereby I remove the links + # When the shortest path method returns 'No path' or when unassigned flow + # is zero, I exit the algorithm. + # + # Even on small graphs, this method is very efficient, despite the overhead + # of using shortest path. For very large graphs, this method outperforms + # all other algorithms by orders of magnitude. + # ----------------------------------------------------------------------- + + edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0] + inverted_graph = Graph(from_list=edges) # create G_inverted. + capacity_graph = Graph() # Create structure to record capacity left. + flow_graph = Graph() # Create structure to record flows. + + while unassigned_flow: + # 1. find the best path + d, path = shortest_path(inverted_graph, start, end) + if d == float("inf"): # then there is no path, and we must exit. + return total_flow, flow_graph + # else: use the path and lookup the actual flow from the capacity graph. + + path_flow = min([min(d, capacity_graph.edge(s, e, default=float("inf"))) for s, e, d in graph.edges(path=path)]) + + # 2. update the unassigned flow. + unassigned_flow -= path_flow + total_flow += path_flow + + # 3. record the flows and update the inverted graph, so that it is + # ready for the next iteration. + edges = graph.edges(path) + for n1, n2, d in edges: + # 3.a. recording: + v = flow_graph.edge(n1, n2, default=None) + if v is None: + flow_graph.add_edge(n1, n2, path_flow) + c = graph.edge(n1, n2) - path_flow + else: + flow_graph.add_edge(n1, n2, value=v + path_flow) + c = graph.edge(n1, n2) - (v + path_flow) + capacity_graph.add_edge(n1, n2, c) + + # 3.b. updating: + # if there is capacity left: update with new 1/capacity + # else: remove node, as we can't do 1/zero. + if c > 0: + inverted_graph.add_edge(n1, n2, 1 / c) + else: + inverted_graph.del_edge(n1, n2) + return total_flow, flow_graph \ No newline at end of file diff --git a/graph-theory/source/graph/max_flow_min_cut.py b/graph-theory/source/graph/max_flow_min_cut.py new file mode 100644 index 0000000000000000000000000000000000000000..02290d25ddbfadc839d86ac656653be40b87a611 --- /dev/null +++ b/graph-theory/source/graph/max_flow_min_cut.py @@ -0,0 +1,38 @@ +from .base import BasicGraph +from .max_flow import maximum_flow + + +def maximum_flow_min_cut(graph, start, end): + """ + Finds the edges in the maximum flow min cut. + :param graph: Graph + :param start: start + :param end: end + :return: list of edges + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError(f"{start} not in graph") + if end not in graph: + raise ValueError(f"{end} not in graph") + + flow, mfg = maximum_flow(graph, start, end) + if flow == 0: + return [] + + cls = type(graph) + working_graph = cls(from_list=mfg.to_list()) + + min_cut = [] + for n1 in mfg.breadth_first_walk(start, end): + n2s = mfg.nodes(from_node=n1) + for n2 in n2s: + if graph.edge(n1, n2) - mfg.edge(n1, n2) == 0: + working_graph.del_edge(n1, n2) + min_cut.append((n1, n2)) + + min_cut_nodes = set(working_graph.nodes(out_degree=0)) + min_cut_nodes.remove(end) + min_cut = [(n1, n2) for (n1, n2) in min_cut if n1 in min_cut_nodes] + return min_cut \ No newline at end of file diff --git a/graph-theory/source/graph/maximum_flow_min_cut.py b/graph-theory/source/graph/maximum_flow_min_cut.py new file mode 100644 index 0000000000000000000000000000000000000000..11119ce079d4e5ba58a4eecb6ffc0cfdcb55e104 --- /dev/null +++ b/graph-theory/source/graph/maximum_flow_min_cut.py @@ -0,0 +1,38 @@ +from .base import BasicGraph +from .max_flow import maximum_flow + + +def maximum_flow_min_cut(graph, start, end): + """ + Finds the edges in the maximum flow min cut. + :param graph: Graph + :param start: start + :param end: end + :return: list of edges + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + Graph = type(graph) + if start not in graph: + raise ValueError(f"{start} not in graph") + if end not in graph: + raise ValueError(f"{end} not in graph") + + flow, mfg = maximum_flow(graph, start, end) + if flow == 0: + return [] + + working_graph = Graph(from_list=mfg.to_list()) + + min_cut = [] + for n1 in mfg.breadth_first_walk(start, end): + n2s = mfg.nodes(from_node=n1) + for n2 in n2s: + if graph.edge(n1, n2) - mfg.edge(n1, n2) == 0: + working_graph.del_edge(n1, n2) + min_cut.append((n1, n2)) + + min_cut_nodes = set(working_graph.nodes(out_degree=0)) + min_cut_nodes.remove(end) + min_cut = [(n1, n2) for (n1, n2) in min_cut if n1 in min_cut_nodes] + return min_cut \ No newline at end of file diff --git a/graph-theory/source/graph/min_cost_flow.py b/graph-theory/source/graph/min_cost_flow.py new file mode 100644 index 0000000000000000000000000000000000000000..fa741f09f92ef7e099f4c46970407de2df7e41a1 --- /dev/null +++ b/graph-theory/source/graph/min_cost_flow.py @@ -0,0 +1,95 @@ +from .base import BasicGraph + + +from bisect import insort + + +def minimum_cost_flow_using_successive_shortest_path(costs, inventory, capacity=None): + """ + Calculates the minimum cost flow solution using successive shortest path. + :param costs: Graph with `cost per unit` as edge + :param inventory: dict {node: stock, ...} + stock < 0 is demand + stock > 0 is supply + :param capacity: None or Graph with `capacity` as edge. + if capacity is None, capacity is assumed to be float('inf') + :return: total costs, flow graph + """ + if not isinstance(costs, BasicGraph): + raise TypeError(f"expected costs as Graph, not {type(costs)}") + Graph = type(costs) + + if not isinstance(inventory, dict): + raise TypeError(f"expected inventory as dict, not {type(inventory)}") + + if not all(d >= 0 for s, e, d in costs.edges()): + raise ValueError("The costs graph has negative edges. That won't work.") + + if not all(isinstance(v, (float, int)) for v in inventory.values()): + raise TypeError("not all stock is numeric.") + + if capacity is None: + capacity = Graph(from_list=[(s, e, float("inf")) for s, e, d in costs.edges()]) + else: + if not isinstance(capacity, Graph): + raise TypeError("Expected capacity as a Graph") + if any(d < 0 for s, e, d in capacity.edges()): + nn = [(s, e) for s, e, d in capacity.edges() if d < 0] + raise ValueError(f"negative capacity on edges: {nn}") + if {(s, e) for s, e, d in costs.edges()} != {(s, e) for s, e, d in capacity.edges()}: + raise ValueError("cost and capacity have different links") + + # successive shortest path algorithm begins ... + # ------------------------------------------------ + paths = costs.copy() # initialise a copy of the cost graph so edges that + # have exhausted capacities can be removed. + flows = Graph() # initialise F as copy with zero flow + capacities = Graph() # initialise C as a copy of capacity, so used capacity + # can be removed. + balance = [(v, k) for k, v in inventory.items() if v != 0] # list with excess/demand, node id + balance.sort() + + distances = paths.all_pairs_shortest_paths() + + while balance: # while determine excess / imbalances: + D, Dn = balance[0] # pick node Dn where the demand D is greatest + if D > 0: + break # only supplies left. + balance = balance[1:] # remove selection. + + supply_sites = [(distances[En][Dn], E, En) for E, En in balance if E > 0] + if not supply_sites: + break # supply exhausted. + supply_sites.sort() + dist, E, En = supply_sites[0] # pick nearest node En with excess E. + balance.remove((E, En)) # maintain balance by removing the node. + + if E < 0: + break # no supplies left. + if dist == float("inf"): + raise Exception("bad logic: Case not checked for.") + + cost, path = paths.shortest_path(En, Dn) # compute shortest path P from E to a node in demand D. + + # determine the capacity limit C on P: + capacity_limit = min(capacities.edge(s, e, default=capacity.edge(s, e)) for s, e in zip(path[:-1], path[1:])) + + # determine L units to be transferred as min(demand @ D and the limit C) + L = min(E, abs(D), capacity_limit) + for s, e in zip(path[:-1], path[1:]): + flows.add_edge(s, e, L + flows.edge(s, e, default=0)) # update F. + new_capacity = capacities.edge(s, e, default=capacity.edge(s, e)) - L + capacities.add_edge(s, e, new_capacity) # update C + + if new_capacity == 0: # remove the edge from potential solutions. + paths.del_edge(s, e) + distances = paths.all_pairs_shortest_paths() + + # maintain balance, in case there is excess or demand left. + if E - L > 0: + insort(balance, (E - L, En)) + if D + L < 0: + insort(balance, (D + L, Dn)) + + total_cost = sum(d * costs.edge(s, e) for s, e, d in flows.edges()) + return total_cost, flows \ No newline at end of file diff --git a/graph-theory/source/graph/minmax.py b/graph-theory/source/graph/minmax.py new file mode 100644 index 0000000000000000000000000000000000000000..4a9bab799b2af552cd138b05a6242696080fe5f6 --- /dev/null +++ b/graph-theory/source/graph/minmax.py @@ -0,0 +1,12 @@ +from .base import BasicGraph + + +def minmax(graph): + """finds the node(s) with shortest distance to all other nodes.""" + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + adj_mat = graph.all_pairs_shortest_paths() + for n in adj_mat: + adj_mat[n] = max(adj_mat[n].values()) + smallest = min(adj_mat.values()) + return [k for k, v in adj_mat.items() if v == smallest] \ No newline at end of file diff --git a/graph-theory/source/graph/minsum.py b/graph-theory/source/graph/minsum.py new file mode 100644 index 0000000000000000000000000000000000000000..9c8bf17381a355a1abbbbe78bcd9902c1d4b6c26 --- /dev/null +++ b/graph-theory/source/graph/minsum.py @@ -0,0 +1,12 @@ +from .base import BasicGraph + + +def minsum(graph): + """finds the mode(s) that have the smallest sum of distance to all other nodes.""" + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + adj_mat = graph.all_pairs_shortest_paths() + for n in adj_mat: + adj_mat[n] = sum(adj_mat[n].values()) + smallest = min(adj_mat.values()) + return [k for k, v in adj_mat.items() if v == smallest] \ No newline at end of file diff --git a/graph-theory/source/graph/partite.py b/graph-theory/source/graph/partite.py new file mode 100644 index 0000000000000000000000000000000000000000..509db5035fe891b3065c530e4ceab60d2db450d8 --- /dev/null +++ b/graph-theory/source/graph/partite.py @@ -0,0 +1,45 @@ +from .base import BasicGraph + + +def is_partite(graph, n): + """Checks if graph is n-partite + :param graph: class Graph + :param n: int, number of partitions. + :return: boolean and partitions as dict[colour] = set(nodes) or None. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + if not isinstance(n, int): + raise TypeError(f"Expected n as integer > 0, not {type(n)}") + colours_and_nodes = {i: set() for i in range(n)} + nodes_and_colours = {} + n1 = set(graph.nodes()).pop() + q = [n1] + visited = set() + colour = 0 + while q: + n1 = q.pop() + visited.add(n1) + + if n1 in nodes_and_colours: + colour = nodes_and_colours[n1] + else: + colours_and_nodes[colour].add(n1) + nodes_and_colours[n1] = colour + + next_colour = (colour + 1) % n + neighbours = graph.nodes(from_node=n1) + graph.nodes(to_node=n1) + for n2 in neighbours: + if n2 in nodes_and_colours: + if nodes_and_colours[n2] == colour: + return False, None + # else: pass # it already has a colour and there is no conflict. + else: # if n2 not in nodes_and_colours: + colours_and_nodes[next_colour].add(n2) + nodes_and_colours[n2] = next_colour + continue + if n2 not in visited: + q.append(n2) + + return True, colours_and_nodes \ No newline at end of file diff --git a/graph-theory/source/graph/random.py b/graph-theory/source/graph/random.py new file mode 100644 index 0000000000000000000000000000000000000000..8e7354f2427b6f552c3299ac7afd8c80ad3dae79 --- /dev/null +++ b/graph-theory/source/graph/random.py @@ -0,0 +1,92 @@ +import random +import itertools + +from .core import Graph + + +def xy_distance(n1, n2): + """ calculates the xy_distance between to (x,y)-nodes""" + x1, y1 = n1 + x2, y2 = n2 + dy, dx = (y2 - y1) * (y2 - y1), (x2 - x1) * (x2 - x1) + return (dy + dx) ** (1 / 2) + + +def random_xy_graph(nodes, x_max, y_max, edges=None, seed=42): + """ Generates a graph with N nodes, M links, where all nodes have x,y in + range [1,1] to [x_max, y_max] + :param nodes: integer + :param x_max: integer (800 pixels for example) + :param y_max: integer (400 pixels for example) + :param edges: integer or None, if None the graph will be fully connected. + :param seed: seed for random number generator + :return: Graph + """ + if x_max * y_max < nodes: + raise ValueError("frame (x:{},y:{}) is too small for {} nodes".format(x_max,y_max,nodes)) + + max_edges = nodes * nodes + if edges is None: + edges = max_edges + if max_edges < edges: + raise ValueError( + "A fully connected graph with {} nodes, would at most have {} edges: {}".format( + nodes, max_edges, edges + )) + + random.seed(seed) + g = Graph() + xy_space = set() + + # Step 1: random search mode + node_count = 0 + while node_count < nodes: + xy = (random.randint(1, x_max), random.randint(1, y_max)) + if xy not in xy_space: + g.add_node(xy) + xy_space.add(xy) + node_count += 1 + continue + + if len(xy_space) > (x_max * y_max) / 2: + # use of random is inefficient --> proceed with step 2. + break + + # Step 2: structured search mode. + if len(g.nodes()) < nodes: + x_range = list(range(1, x_max+1)) + random.shuffle(x_range) + y_range = list(range(1, y_max+1)) + random.shuffle(y_range) + quit = False + for x in x_range: + if quit: + break + for y in y_range: + xy = (x, y) + if xy in xy_space: + continue + else: + g.add_node(xy) + xy_space.add(xy) + node_count += 1 + + if len(xy_space) == nodes: + quit = True + break + + n1s = g.nodes() + random.shuffle(n1s) + n2s = n1s[:] + random.shuffle(n2s) + + edge_count = 0 + for n1, n2 in itertools.product(*[n1s, n2s]): + if edge_count == edges: + break + edge_count += 1 + + d = xy_distance(n1, n2) + g.add_edge(n1, n2, d) + + return g \ No newline at end of file diff --git a/graph-theory/source/graph/shortest_path.py b/graph-theory/source/graph/shortest_path.py new file mode 100644 index 0000000000000000000000000000000000000000..5a0e14fb93a8783bd7e8ad14c909675d9abc3912 --- /dev/null +++ b/graph-theory/source/graph/shortest_path.py @@ -0,0 +1,359 @@ +# Graph functions +# ----------------------------- +from bisect import insort +from .base import BasicGraph +from collections import defaultdict + + +from heapq import heappop, heappush + + +def shortest_path(graph, start, end, avoids=None): + """single source shortest path algorithm. + :param graph: class Graph + :param start: start node + :param end: end node + :param avoids: optional set,frozenset or list of nodes that cannot be a part of the path. + :return distance, path (as list), + returns float('inf'), [] if no path exists. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError(f"{start} not in graph") + if end not in graph: + raise ValueError(f"{end} not in graph") + if avoids is None: + visited = set() + elif not isinstance(avoids, (frozenset, set, list)): + raise TypeError(f"Expect obstacles as set or frozenset, not {type(avoids)}") + else: + visited = set(avoids) + + q, minimums = [(0, 0, start, ())], {start: 0} + i = 1 + while q: + (cost, _, v1, path) = heappop(q) + if v1 not in visited: + visited.add(v1) + path = (v1, path) + + if v1 == end: # exit criteria. + L = [] + while path: + v, path = path[0], path[1] + L.append(v) + L.reverse() + return cost, L + + for _, v2, dist in graph.edges(from_node=v1): + if v2 in visited: + continue + prev = minimums.get(v2, None) + next_node = cost + dist + if prev is None or next_node < prev: + minimums[v2] = next_node + heappush(q, (next_node, i, v2, path)) + i += 1 + return float("inf"), [] + + +class ScanThread(object): + __slots__ = ["cost", "n1", "path"] + + """ search thread for bidirectional search """ + + def __init__(self, cost, n1, path=()): + if not isinstance(path, tuple): + raise TypeError(f"Expected a tuple, not {type(path)}") + self.cost = cost + self.n1 = n1 + self.path = path + + def __lt__(self, other): + return self.cost < other.cost + + def __str__(self): + return f"{self.cost}:{self.path}" + + +class BiDirectionalSearch(object): + """data structure for organizing bidirectional search""" + + forward = True + backward = False + + def __str__(self): + if self.forward == self.direction: + return "forward scan" + return "backward scan" + + def __init__(self, graph, start, direction=True, avoids=None): + """ + :param graph: class Graph. + :param start: first node in the search. + :param direction: bool + :param avoids: nodes that cannot be a part of the solution. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError("start not in graph.") + if not isinstance(direction, bool): + raise TypeError(f"Expected boolean, not {type(direction)}") + if avoids is None: + self.avoids = frozenset() + elif not isinstance(avoids, (frozenset, set, list)): + raise TypeError(f"Expect obstacles as set or frozenset, not {type(avoids)}") + else: + self.avoids = frozenset(avoids) + + self.q = [] + self.q.append(ScanThread(cost=0, n1=start)) + self.graph = graph + self.boundary = set() # visited. + self.mins = {start: 0} + self.paths = {start: ()} + self.direction = direction + self.sp = () + self.sp_length = float("inf") + + def update(self, sp, sp_length): + if sp_length > self.sp_length: + raise ValueError("Bad logic!") + self.sp = sp + self.sp_length = sp_length + + def search(self, other): + assert isinstance(other, BiDirectionalSearch) + if not self.q: + return + + sp, sp_length = self.sp, self.sp_length + + st = self.q.pop(0) + assert isinstance(st, ScanThread) + if st.cost > self.sp_length: + return + + self.boundary.add(st.n1) + + if st.n1 in other.boundary: # if there's an intercept between the two searches ... + if st.cost + other.mins[st.n1] < self.sp_length: + sp_length = st.cost + other.mins[st.n1] + if self.direction == self.forward: + sp = tuple(reversed(st.path)) + (st.n1,) + other.paths[st.n1] + else: # direction == backward: + sp = tuple(reversed(other.paths[st.n1])) + (st.n1,) + st.path + + self.q = [a for a in self.q if a.cost < sp_length] + + if self.direction == self.forward: + edges = sorted((d, e) for s, e, d in self.graph.edges(from_node=st.n1) if e not in self.avoids) + else: + edges = sorted((d, s) for s, e, d in self.graph.edges(to_node=st.n1) if s not in self.avoids) + + for dist, n2 in edges: + n2_dist = st.cost + dist + if n2_dist > self.sp_length: # no point pursuing as the solution is worse. + continue + if n2 in other.mins and n2_dist + other.mins[n2] > self.sp_length: # already longer than lower bound. + continue + + # at this point we can't dismiss that n2 will lead to a better solution, so we retain it. + prev = self.mins.get(n2, None) + if prev is None or n2_dist < prev: + self.mins[n2] = n2_dist + path = (st.n1,) + st.path + self.paths[n2] = path + insort(self.q, ScanThread(n2_dist, n2, path)) + + self.update(sp, sp_length) + other.update(sp, sp_length) + + +def shortest_path_bidirectional(graph, start, end, avoids=None): + """Bidirectional search using lower bound. + :param graph: Graph + :param start: start node + :param end: end node + :param avoids: nodes that cannot be a part of the shortest path. + :return: shortest path + In Section 3.4.6 of Artificial Intelligence: A Modern Approach, Russel and + Norvig write: + Bidirectional search is implemented by replacing the goal test with a check + to see whether the frontiers of the two searches intersect; if they do, + a solution has been found. It is important to realize that the first solution + found may not be optimal, even if the two searches are both breadth-first; + some additional search is required to make sure there isn't a shortcut + across the gap. + To overcome this limit for weighted graphs, I've added a lower bound, so + that when the two searches intersect, the lower bound is updated and the + lower bound path is stored. In subsequent searches any path shorter than + the lower bound, leads to an update of the lower bound and shortest path. + The algorithm stops when all nodes on the frontier exceed the lower bound. + ---------------- + The algorithms works as follows: + Lower bound = float('infinite') + shortest path = None + Two queues (forward scan and backward scan) are initiated with respectively + the start and end node as starting point for each scan. + while there are nodes in the forward- and backward-scan queues: + 1. select direction from (forward, backward) in alternations. + 2. pop the top item from the queue of the direction. + (The top item contains the node N that is nearest the starting point for the scan) + 3. Add the node N to the scan-directions frontier. + 4. If the node N is in the other directions frontier: + the path distance from the directions _start_ to the _end_ via + the point of intersection (N), is compared with the lower bound. + If the path distance is less than the lower bound: + *lower bound* is updated with path distance, and, + the *shortest path* is recorded. + 5. for each node N2 (to N if backward, from N if forward): + the distance D is accumulated + if D > lower bound, the node N2 is ignored. + if N2 is within the other directions frontier and D + D.other > lower bound, the node N2 is ignored. + otherwise: + the path P recorded + and N2, D and P are added to the directions scan queue + The algorithm terminates when the scan queues are exhausted. + ---------------- + Given that: + - `c` is the connectivity of the nodes in the graph, + - `R` is the length of the path, + the explored solution landscape can be estimated as: + A = c * (R**2), for single source shortest path + A = c * 2 * (1/2 * R) **2, for bidirectional shortest path + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if start not in graph: + raise ValueError("start not in graph.") + if end not in graph: + raise ValueError("end not in graph.") + + forward = BiDirectionalSearch(graph, start=start, direction=BiDirectionalSearch.forward, avoids=avoids) + backward = BiDirectionalSearch(graph, start=end, direction=BiDirectionalSearch.backward, avoids=avoids) + + while any((forward.q, backward.q)): + forward.search(other=backward) + backward.search(other=forward) + + return forward.sp_length, list(forward.sp) + + +class ShortestPathCache(object): + """ + Data structure optimised for repeated calls to shortest path. + Used by shortest path when using keyword `memoize=True` + """ + + def __init__(self, graph): + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected type Graph, not {type(graph)}") + self.graph = graph + self.cache = {} + self.repeated_cache = {} + + def _update_cache(self, path): + """private method for updating the cache for future lookups. + :param path: tuple of nodes + Given a shortest path, all steps along the shortest path, + also constitute the shortest path between each pair of steps. + """ + if not isinstance(path, (list, tuple)): + raise TypeError + b = len(path) + if b <= 2: + dist = self.graph.distance_from_path(path) + self.cache[(path[0], path[-1])] = (dist, tuple(path)) + + for a, _ in enumerate(path): + section = tuple(path[a : b - a]) + if len(section) < 3: + break + dist = self.graph.distance_from_path(section) + self.cache[(section[0], section[-1])] = (dist, section) + + for ix, start in enumerate(path[1:-1]): + section = tuple(path[ix:]) + dist = self.graph.distance_from_path(section) + self.cache[(section[0], section[-1])] = (dist, section) + + def shortest_path(self, start, end, avoids=None): + """Shortest path method that utilizes caching and bidirectional search""" + if start not in self.graph: + raise ValueError("start not in graph.") + if end not in self.graph: + raise ValueError("end not in graph.") + if avoids is None: + pass + elif not isinstance(avoids, (frozenset, set, list)): + raise TypeError(f"Expect obstacles as None, set or frozenset, not {type(avoids)}") + else: + avoids = frozenset(avoids) + + if isinstance(avoids, frozenset): + # as avoids can be volatile, it is not possible to benefit from the caching + # methodology. This does however not mean that we need to forfeit the benefit + # of bidirectional search. + hash_key = hash(avoids) + d, p = self.repeated_cache.get((start, end, hash_key), (None, None)) + if d is None: + d, p = shortest_path_bidirectional(self.graph, start, end, avoids=avoids) + self.repeated_cache[(start, end, hash_key)] = (d, p) + else: + d, p = self.cache.get((start, end), (None, None)) + + if d is None: # search for it. + _, p = shortest_path_bidirectional(self.graph, start, end) + if not p: + self.cache[(start, end)] = (float("inf"), []) + else: + self._update_cache(p) + d, p = self.cache[(start, end)] + + return d, list(p) + + +class SPLength(object): + def __init__(self): + self.value = float("inf") + + +def distance_from_path(graph, path): + """Calculates the distance for the path in graph + :param graph: class Graph + :param path: list of nodes + :return: distance + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + if not isinstance(path, (tuple, list)): + raise TypeError(f"expected tuple or list, not {type(path)}") + + cache = defaultdict(dict) + path_length = 0 + for idx in range(len(path) - 1): + n1, n2 = path[idx], path[idx + 1] + + # if the edge exists... + d = graph.edge(n1, n2, default=None) + if d: + path_length += d + continue + + # if we've seen the edge before... + d = cache.get((n1, n2), None) + if d: + path_length += d + continue + + # if there no alternative ... (search) + d, _ = shortest_path(graph, n1, n2) + if d == float("inf"): + return float("inf") # <-- Exit if there's no path. + else: + cache[(n1, n2)] = d + path_length += d + return path_length diff --git a/graph-theory/source/graph/shortest_tree_all_pairs.py b/graph-theory/source/graph/shortest_tree_all_pairs.py new file mode 100644 index 0000000000000000000000000000000000000000..a4a68988568a3025805803eb9bcd211860efe5cd --- /dev/null +++ b/graph-theory/source/graph/shortest_tree_all_pairs.py @@ -0,0 +1,43 @@ +from .base import BasicGraph +from .all_pairs_shortest_path import all_pairs_shortest_paths + + +def shortest_tree_all_pairs(graph): + """ + 'minimize the longest distance between any pair' + Note: This algorithm is not shortest path as it jumps + to a new branch when it has exhausted a branch in the tree. + :return: path + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + g = all_pairs_shortest_paths(graph) + assert isinstance(g, dict) + + distance = float("inf") + best_starting_point = -1 + # create shortest path gantt diagram. + for start_node in g.keys(): + if start_node in g: + dist = sum(v for k, v in g[start_node].items()) + if dist < distance: + best_starting_point = start_node + # else: skip the node as it's isolated. + g2 = g[best_starting_point] # {1: 0, 2: 1, 3: 2, 4: 3} + + inv_g2 = {} + for k, v in g2.items(): + if v not in inv_g2: + inv_g2[v] = set() + inv_g2[v].add(k) + + all_nodes = set(g.keys()) + del g + path = [] + while all_nodes and inv_g2.keys(): + v_nearest = min(inv_g2.keys()) + for v in inv_g2[v_nearest]: + all_nodes.remove(v) + path.append(v) + del inv_g2[v_nearest] + return path \ No newline at end of file diff --git a/graph-theory/source/graph/topological_sort.py b/graph-theory/source/graph/topological_sort.py new file mode 100644 index 0000000000000000000000000000000000000000..c26bda147f8d3b8b6500e463a594b71c4fdfe408 --- /dev/null +++ b/graph-theory/source/graph/topological_sort.py @@ -0,0 +1,36 @@ +from .base import BasicGraph + + +def topological_sort(graph, key=None): + """Return a generator of nodes in topologically sorted order. + :param graph: Graph + :param key: optional function for sortation. + :return: Generator + Topological sort (ordering) is a linear ordering of vertices. + https://en.wikipedia.org/wiki/Topological_sorting + Note: The algorithm does not check for loops before initiating + the sortation, but raise AttributeError at the first conflict. + This saves O(m+n) runtime. + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + if key is None: + + def key(x): + return x + + g2 = graph.copy() + + zero_in_degree = sorted(g2.nodes(in_degree=0), key=key) + + while zero_in_degree: + for task in zero_in_degree: + yield task # <--- do something. + + g2.del_node(task) + + zero_in_degree = sorted(g2.nodes(in_degree=0), key=key) + + if g2.nodes(): + raise AttributeError(f"Graph is not acyclic: Loop found: {g2.nodes()}") \ No newline at end of file diff --git a/graph-theory/source/graph/traffic_scheduling_problem.py b/graph-theory/source/graph/traffic_scheduling_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..93ee73fa8c4ac4426b12e39c4623c3543d250f1e --- /dev/null +++ b/graph-theory/source/graph/traffic_scheduling_problem.py @@ -0,0 +1,569 @@ +from time import process_time +from .base import BasicGraph +from bisect import insort +from itertools import product + + +__description__ = """ +We've decided to refer to the optimisation problem of finding +the fewest number of moves that resolve a traffic jam as +a traffic scheduling problem. +""" + + +class UnSolvable(ValueError): + """ Value Error raised if the inputs have no solution. """ + pass + + +class NoSolution(ValueError): + """ Value Error raised if the method could not identify a valid solution """ + pass + + +class StopCondition(Exception): + """ exception used to stop the search """ + pass + + +class Timer(object): + def __init__(self, timeout=None): + """ + :param timeout: int/float in milliseconds. + """ + if timeout is None: + timeout = float('inf') + if not isinstance(timeout, (float, int)): + raise ValueError(f"timeout is {type(timeout)} not int or float > 0") + if timeout < 0: + raise ValueError(f"timeout must be >0, but was {timeout}") + + self.limit = timeout + self.start = process_time() + self._counter = 0 + self._expired = False + + def expired(self): + """ returns bool""" + if self._expired: + return True + + # we use a counter as there is no reason to check the time 100_000 times/second. + if self._counter > 0: + self._counter -= 1 + return False + # The counter was zero, so now we check the time and reset the counter. + self._counter = 100 + if process_time() - self.start > (self.limit / 1000): + self._expired = True + return False + + +class Load(object): + _empty = frozenset() + + __slots__ = ["id", "start", "ends", "prohibited"] + + def __init__(self, id, start, ends=None, prohibited=None): + """ + :param id: unique load reference + :param start: start node + :param ends: end node(s) + - list, set, frozenset, tuples are interpreted as a number of candidate destinations. + - all other types are interpreted as 1 destination. + :param prohibited: iterable with nodes that cannot be in the solution. + """ + self.id = id + self.start = start + if isinstance(ends, frozenset): + if not ends: + raise ValueError(f"end is an empty {type(ends)}?") + self.ends = ends + elif isinstance(ends, (list, set, tuple)): + if not ends: + raise ValueError(f"end is an empty {type(ends)}?") + self.ends = frozenset(ends) + elif ends is None: + self.ends = frozenset([start]) + else: + self.ends = frozenset([ends]) + assert isinstance(self.ends, frozenset), "bad logic!" + + if prohibited is not None: + if not isinstance(prohibited, (list, frozenset, set, tuple)): + raise TypeError(f"Got {type(prohibited)}, expected list, set or tuple") + self.prohibited = frozenset(prohibited) + else: + self.prohibited = Load._empty # link to an empty frozen set. + + def __str__(self): + return f"Load(id={self.id}, start={self.start}, end={self.ends}, prohibited={self.prohibited})" + + def __repr__(self): + return self.__str__() + + def __eq__(self, other): + if not isinstance(other, Load): + raise TypeError + return all([ + self.start == other.start, + self.ends == other.ends, + self.prohibited == other.prohibited + ]) + + +# helpers +def check_user_input(graph, loads): + """ checks the user inputs to be valid. + + :param graph network available for routing. + :param loads: dictionary or list with load id and preferred route. Examples: + + loads_as_list = [ + {'id': 1, 'start': 1, 'end': 3}, # keyword prohibited is missing. + {'id': 2, 'start': 2, 'end': [3, 4, 5], 'prohibited': [7, 8, 9]}, + {'id': 3, 'start': 3, 'end': [4, 5], 'prohibited': [2]} # gateway to off limits. + {'id': 4, 'start': 8} # load 4 is where it needs to be. + ] + + loads_as_dict = { + 1: (1, 3), # start, end, None + 2: (2, [3, 4, 5], [7, 8, 9]), # start, end(s), prohibited + 3: (3, [4, 5], [2]), + 4: (8, ), + } + + returns: list of Loads + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + all_loads = {} + all_nodes = set() + if isinstance(loads, list): + for d in loads: + if not isinstance(d, dict): + raise TypeError(f"Got {type(d)}, expected dict.") + L = Load(**d) + all_loads[L.id] = L + all_nodes.add(L.start) + all_nodes.update(L.ends) + elif isinstance(loads, dict): + for i, t in loads.items(): + if not isinstance(t, (tuple, list)): + raise TypeError(f"Got {type(t)}, expected tuple") + L = Load(i, *t) + all_loads[L.id] = L + all_nodes.add(L.start) + all_nodes.update(L.ends) + else: + raise TypeError("loads not recognised. Please see docstring.") + + if not all_nodes.issubset(set(graph.nodes())): # then something is wrong. Let's analyze to help the programmer... + diff = all_nodes.difference(set(graph.nodes())) + for load in all_loads.values(): + if load.start in diff: + raise ValueError(f"Load {load.id}'s start ({load.start}) is not in the graph.") + if load.ends.intersection(diff): + raise ValueError(f"Load {load.id}'s ends ({load.ends.intersection(diff)}) is/are not in the graph.") + if load.prohibited.intersection(diff): + raise ValueError(f"Load {load.id}'s prohibited node(s) ({load.prohibited.intersection(diff)}) is/are not in the graph.") + + assignment_options = {load.id: frozenset(load.ends) for load in all_loads.values() } + if not is_ap_solvable(assignment_options): + raise UnSolvable(f"There are not enough ends for all the loads to be assigned to a destination.") + + for load in all_loads.values(): + if load.prohibited: + gc = graph.copy() + for n in load.prohibited: + gc.del_node(n) + else: + gc = graph + + for node in gc.breadth_first_walk(start=load.start): + if node in load.ends: + break + else: + ends = f"any {tuple(load.ends)}" if len(load.ends)>1 else f"{list(load.ends)[0]}" + raise UnSolvable(f"load {load.id} has no path from {load.start} to {ends}") + return all_loads + + +def is_ap_solvable(assignments): + """ + A number of loads need to be assigned to a destination. + The loads have preferences, f.x. + + A = {1,2}, B = {2,3}, C = {1,2,3} # solveable + A = {1,2}, B = {1,3}, C = {1} # solveable + A = {1,2}, B = {1,2}, C = {1} # not solveable. + + This method checks if the assignment is possible + """ + if not isinstance(assignments, dict): + raise TypeError + if not all(isinstance(i, (frozenset, set)) for i in assignments.values()): + raise TypeError + + all_ends = set().union(*assignments.values()) + + assignment = {} + + for load_id, ends in sorted(assignments.items(), key=lambda x: len(x[-1])): + options = set(ends).intersection(all_ends) + if not options: + return False + selection = options.pop() + all_ends.remove(selection) + assignment[load_id] = selection + return True + + +def path_to_moves(path): + """ + translate path with states into a motion sequence. + :param path: list of tuples with [(load id, location), ... ] + """ + moves = [] + s1 = path[0] + for s2 in path[1:]: + for p1, p2 in zip(s1, s2): + if p1 != p2: + moves.append({p1[0]: (p1[1], p2[1])}) # {load id: (location1, location2)} + s1 = s2 + return moves + + +def moves_to_synchronous_moves(moves, loads): + """ translates the list of moves returned from the traffic jam solver to a list + of moves that can be made concurrently. + + :param moves: list of loads and moves, e.g. [{1: (2,3)}, {2:(1,2)}, ... ] + :param loads: dict with loads and paths, e.g. {1: [2,3,4], 2: [1,2,3], ... } + :return: list of synchronous loads and moves, e.g. [{1:(2,3), {2:(1,2}}, {1:(3,4), 2:(2,3)}, ...] + """ + moves = [(k,) + v for move in moves for k, v in move.items()] # create independent copy + assert isinstance(loads, dict) + assert all(isinstance(ld, Load) for ld in loads.values()) + + occupied_locations = {L.start for L in loads.values()} # loads are required in case that a load doesn't move. + synchronous = [] + + while moves: + current_moves = {} + for move in moves[:]: + load, n1, n2 = move + if load in current_moves: + break + if n2 in occupied_locations: + continue + current_moves[load] = (n1, n2) + occupied_locations.remove(n1) + occupied_locations.add(n2) + moves.remove(move) + synchronous.append(current_moves) + return synchronous + + +class State(object): + def __init__(self, loads, distance=0, gradient=float('inf')): + self.loads = loads + self._hash = hash(self.loads) # by pre-calculating the hash, we save cpu time later. + self.distance = distance + self.gradient = gradient + self._d = None # for most cases this isn't needed. + + def __str__(self): + return f"State({self.loads}, {self.distance})" + + def __repr__(self): + return str(self) + + def __lt__(self, other): + if self.gradient == other.gradient: + return self.distance < other.distance + else: + return self.gradient < other.gradient + + def __iter__(self): + for lid, loc in self.loads: + yield lid, loc + + def __hash__(self): + return self._hash + + def __eq__(self, other): + # this is actually required for dict's to work. For more see example on: + # https://stackoverflow.com/questions/9010222/why-can-a-python-dict-have-multiple-keys-with-the-same-hash?noredirect=1&lq=1 + return self._hash == other._hash + + def occupied(self): + return {i[1] for i in self.loads} + + +class JamSolver(object): + def __init__(self, graph, loads, timer): + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + Graph = type(graph) + if not isinstance(loads, dict): + raise TypeError + if not all(isinstance(i, Load) for i in loads.values()): + raise TypeError + if not all(lid == load.id for lid, load in loads.items()): + raise ValueError + if not isinstance(timer, Timer): + raise TypeError + + self.graph = graph + self.movements = Graph() + self.loads = loads + self.timer = timer + + initial_state = State(loads=tuple((ld.id, ld.start) for ld in self.loads.values()), distance=0) + self.start = initial_state + self.ends = set() + + self.movements.add_node(initial_state) + + self.forward_queue = [initial_state] # this is the working queue with priority. + self.forward_edge = {initial_state: initial_state} # this is a duplicate of items in the work queue + self.forward_visited = set() # we don't want to spend CPU time on this. + + self.reverse_queue = [] + self.reverse_edge = {} + self.reverse_visited = set() + + self.max_search_distance = float('inf') + + self.final_states = set() + + for state in self._end_state_gen(): + self.ends.add(state) + self.reverse_queue.append(state) + self.reverse_edge[state] = state + self.final_states.add(state) + + self.distance_maps = {} + # The distance maps are used as proxy for simulated annealing. + # The closer a load is to any of it's destinations, the lower the temperature. + # when all loads have reach a destination, the temperature is zero. + for load_id, load in self.loads.items(): + self.distance_maps[load_id] = self.graph.distance_map(ends=load.ends, reverse=True) + + self.done = False + self.return_on_first = False + + def __str__(self): + s = "timed out" if self.timer.expired() else "running" + return f"<{self.__class__.__name__}> {s}" + + def _distance(self, load_id, location): + try: + return self.distance_maps[load_id][location] + except KeyError: + return max(self.distance_maps[load_id].values()) + 1 + + def solve(self, return_on_first=False): + if not isinstance(return_on_first, bool): + raise TypeError + self.return_on_first = return_on_first + + try: + self._search() + except StopCondition as e: + print(str(e)) + return self._shortest_path_multiple_ends() + + def _end_state_gen(self): + ids, destinations = [], [] + for load in self.loads.values(): + ids.append(load.id) + destinations.append(list(load.ends)) + + for combo in product(*destinations): + if len(set(combo)) != len(destinations): + continue # it's a duplicate. + state = tuple((lid, loc) for lid, loc in zip(ids, combo)) + yield State(state) + + def _search(self): + while not self.timer.expired(): + + self._find_forward_options() # forward search + self._find_reverse_options() # reverse search + + if not any((self.forward_queue, self.reverse_queue)): + raise StopCondition("queue exhausted") + # note: This may mean the solution-landscape is exhausted. Not that something is wrong. + + def _find_forward_options(self): + if not self.forward_queue: + return + state = self.forward_queue.pop(0) + self.forward_edge.pop(state) + self.forward_visited.add(state) + + occupied = state.occupied() + for load_id, location in state: + load = self.loads[load_id] + + options = sorted((d, e) for s, e, d in self.graph.edges(from_node=location) + if e not in occupied and e not in load.prohibited) + + for distance, option in options: + new_distance_traveled = state.distance + distance + + loads = tuple((lid, loc) if lid != load_id else (load_id, option) for lid, loc in state) + gradient = sum((self._distance(lid, loc) for lid, loc in loads)) + new_state = State(loads, new_distance_traveled, gradient) + + if self.movements.edge(state, new_state, float('inf')) < distance: + continue + else: + self.movements.add_edge(state, new_state, distance) + + if new_state in self.forward_edge: + existing_new_state = self.forward_edge.get(new_state) + if new_state < existing_new_state: # replace! + self.forward_edge[new_state] = new_state + self.forward_queue.remove(existing_new_state) + insort(self.forward_queue, new_state) + else: + pass + continue # case is already queued for testing. + elif new_state in self.forward_visited or new_state in self.reverse_visited: + continue # seen before + else: + self.forward_edge[new_state] = new_state + insort(self.forward_queue, new_state) + + if new_state in self.reverse_visited: + self._match() + + def _shortest_path_multiple_ends(self): + """ helper that identifies the fewest number of moves required to reach any + of the valid end states """ + d_min, p_min = float('inf'), None + for end in self.final_states: + if end in self.movements: + d, p = self.movements.shortest_path(self.start, end) + if d < d_min: # then this solution is better than the previous. + d_min = d + p_min = p + return d_min, p_min + + def _match(self): + """ helper that updates the search queues when one finds a matching state in the other.""" + d, p = self._shortest_path_multiple_ends() + self.max_search_distance = min(d, self.max_search_distance) + + self.forward_visited.update({s for s in self.forward_queue if s.distance > self.max_search_distance}) + self.forward_queue = [s for s in self.forward_queue if s.distance <= self.max_search_distance] + self.forward_edge = {s: s for s in self.forward_queue} + + self.reverse_visited.update({s for s in self.reverse_queue if s.distance > self.max_search_distance}) + self.reverse_queue = [s for s in self.reverse_queue if s.distance <= self.max_search_distance] + self.reverse_edge = {s: s for s in self.reverse_queue} + + if self.return_on_first: + raise StopCondition("solution found") + + def _find_reverse_options(self): + if not self.reverse_queue: # backward... + return + state = self.reverse_queue.pop(0) + self.reverse_edge.pop(state) + self.reverse_visited.add(state) + + occupied = state.occupied() + for load_id, location in state: + load = self.loads[load_id] + + options = sorted((d, s) for s, e, d in self.graph.edges(to_node=location) if + s not in occupied and s not in load.prohibited) + + for distance, option in options: + new_distance_traveled = state.distance + distance + + loads = tuple((lid, loc) if lid != load_id else (load_id, option) for lid, loc in state) + gradient = sum((self._distance(lid, loc) for lid, loc in loads)) + new_state = State(loads, new_distance_traveled, gradient) + + if self.movements.edge(new_state, state, float('inf')) < distance: + continue + else: + self.movements.add_edge(new_state, state, distance) + + if new_state in self.reverse_edge: + existing_new_state = self.reverse_edge.get(new_state) + if new_state < existing_new_state: # replace! + self.reverse_edge[new_state] = new_state + self.reverse_queue.remove(existing_new_state) + insort(self.reverse_queue, new_state) + else: + pass + continue # case is already queued for testing. + elif new_state in self.reverse_visited or new_state in self.forward_visited: + continue # seen before + else: + self.reverse_edge[new_state] = new_state + insort(self.reverse_queue, new_state) + + if new_state in self.forward_visited: + self._match() + + +def jam_solver(graph, loads, timeout=None, synchronous_moves=True, return_on_first=False): + """ + The traffic jam solver + - a bidirectional search algorithm that uses simulated annealing + to induce bias to accelerate the solvers direction of search. + + :param graph network available for routing. + :param loads: dictionary or list with load id and preferred route. Examples: + + loads_as_list = [ + {'id': 1, 'start': 1, 'end': 3}, # keyword prohibited is missing. + {'id': 2, 'start': 2, 'end': [3, 4, 5], 'prohibited': [7, 8, 9]}, + {'id': 3, 'start': 3, 'end': [4, 5], 'prohibited': [2]} # gateway to off limits. + {'id': 4, 'start': 8} # load 4 is where it needs to be. + ] + + loads_as_dict = { + 1: (1, 3), # start, end, None + 2: (2, [3, 4, 5], [7, 8, 9]), # start, end(s), prohibited + 3: (3, [4, 5], [2]), + 4: (8, ), + } + + :param timeout: None or Number of milliseconds. + :param synchronous_moves: boolean, set to True to return concurrent moves + :param return_on_first: boolean, tell solver to stop at first valid solution, + disregarding whether the solution is the most energy + efficient. + :return: list of dictionaries as sequence of moves. Example: + + solution = [{'b': (5, 6), 'c': (4, 5), 'e': (1, 4)}, # 1st moves. + {'b': (6, 3), 'c': (5, 6), 'e': (4, 5), 'a': (2, 1)}, # 2nd moves. + {'b': (3, 2), 'c': (6, 3), 'e': (5, 6)}, # 3rd moves. + {'e': (6, 9)}] # 4th move. + + """ + all_loads = check_user_input(graph, loads) + timer = Timer(timeout) + c = JamSolver(graph, all_loads, timer) + d, p = c.solve(return_on_first) + + if not p: + if timer.expired(): + raise UnSolvable(f"no solution found with timeout = {timeout} msecs") + else: + raise NoSolution(f"no solution found.") + + moves = path_to_moves(p) + if synchronous_moves: + return moves_to_synchronous_moves(moves, all_loads) + return moves + diff --git a/graph-theory/source/graph/transshipment_problem.py b/graph-theory/source/graph/transshipment_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..83f905e90fd6e2aa990785bcb5bb5ee9e610c5f4 --- /dev/null +++ b/graph-theory/source/graph/transshipment_problem.py @@ -0,0 +1,246 @@ +from graph import Graph +import itertools + +__description__ = """ +Transshipment problems form a subgroup of transportation problems, where +transshipment is allowed. In transshipment, transportation may or must go +through intermediate nodes, possibly changing modes of transport. +Transshipment or Transhipment is the shipment of goods or containers to an +intermediate destination, and then from there to yet another destination. One +possible reason is to change the means of transport during the journey (for +example from ship transport to road transport), known as transloading. Another +reason is to combine small shipments into a large shipment (consolidation), +dividing the large shipment at the other end (deconsolidation). Transshipment +usually takes place in transport hubs. Much international transshipment also +takes place in designated customs areas, thus avoiding the need for customs +checks or duties, otherwise a major hindrance for efficient transport. +[1](https://en.wikipedia.org/wiki/Transshipment_problem) +""" + + +def clondike_transshipment_problem(): + """ + A deep gold mining operation is running at full speed. + + Problem: + What schedule guarantees an optimal throughput given unpredictable output + from the mines and unpredictable needs for mining equipment? + + Constraints: + The gold mine has a surface depot which connects the 4 mining levels using + an elevator running in the main vertical mine shaft. + At each level there is a narrow gage electric train which can pull rail cars + between the lift and side tracks where excavation occurs. + Loading minerals and unloading equipment takes time, so the best way to + avoid obstructing the busy lift is by moving the rail cars directly into + the lift. However as mining equipment and valuable minerals are very heavy, + the lift can only move one load at the time. + Similarly the best way to avoid obstructing the railway at each level is by + by moving the narrow gage rail cars onto side tracks that are available at + each horizontal mine entry. + Schematic of the mine: + Mining shaft lift to surface depot. + ^ + | + +- level 1 <-------------------> + | 1 2 3 ... N (horizontal mine shafts) + | + +- level 2 <-------------------> + | 1 2 3 ... N + | + +- level 3 <-------------------> + | 1 2 3 ... N + | + +- level 4 <-------------------> + | 1 2 3 ... N + | + +- level N + In the intersection between the mining shaft lift and the electric + locomotive there is limited space to perform any exchange, and because of + constraints of the equipment, the order of delivery is strict: + ^ towards surface. + | + | (railway switch) + | | + [ from lift ] ---->[S]<-->[ electric locomotive ]<---> into the mine. + [ onto lift ] <-----| + | + | + v into the mine. + """ + paths = [ + ("Surface", "L-1", 1), + ("L-1", "L-2", 1), + ("L-2", "L-3", 1), + ("L-3", "L-4", 1), + ("L-1", "L-1-1", 1), + ("L-2", "L-2-1", 1), + ("L-3", "L-3-1", 1), + ("L-4", "L-4-1", 1), + ] + + for level in [1, 2, 3, 4]: # adding stops for the narrow gage trains in the levels. + paths.append(("L-{}".format(level), "L-{}-1".format(level), 1), ) + for dig in [1, 2, 3, 4, 5, 6]: + paths.append(("L-{}-{}".format(level, dig), "L-{}-{}".format(level, dig + 1), 1)) + + paths.extend([(n2, n1, d) for n1, n2, d in paths]) # adding the reverse path. + g = Graph(from_list=paths) + return g + + +class Train(object): + def __init__(self, rail_network, start_location, access): + """ + :param rail_network: the while rail network as a Graph. + :param start_location: a node in the network. + :param access: Set of nodes to which this train has access. + """ + assert isinstance(rail_network, Graph) + self._rail_network = rail_network + assert start_location in self._rail_network.nodes() + self._current_location = start_location + assert isinstance(access, set) + assert all([n in self._rail_network for n in access]) + self._access_nodes = access + + self._schedule = [] + + def schedule(self, jobs=None): + """ + Initialise the solution using shortest jobs first. + Then improve the solution using combinatorics until improvement is zero + param: jobs, (optional) list of jobs + returns: list of jobs in scheduled order. + """ + if jobs is None: + return self._schedule + assert isinstance(jobs, list) + new_jobs = find(rail_network=self._rail_network, stops=self._access_nodes, jobs=jobs) + self._schedule = schedule(graph=self._rail_network, start=self._current_location, jobs=new_jobs) + return self._schedule + + +def schedule_rail_system(rail_network, trains, jobs): + """ + Iterative over the trains until a feasible schedule is found. + 1. Each device loop through the jobs: + select all relevant jobs. + create itinerary items on the jobs. + when all itineraries are complete, return the schedule. + """ + assert isinstance(rail_network, Graph) + assert isinstance(trains, list) + assert all(isinstance(t, Train) for t in trains) + assert isinstance(jobs, list) + + for train in trains: + assert isinstance(train, Train) + train.schedule(jobs) + + +def find(rail_network, stops, jobs): + """ + Finds the route sections that the jobs need to travel from/to (stops) + in the rail network. + :param rail_network: class Graph + :param stops: set of train stops + :param jobs: list of jobs. + :return: sub jobs. + """ + sub_jobs = [] + for A, B in jobs: + if A not in rail_network: + raise ValueError("{} not in rail network".format(A)) + if B not in rail_network: + raise ValueError("{} not in rail network".format(B)) + + _, path = rail_network.shortest_path(A, B) + part_route = [p for p in path if p in stops] + + if not rail_network.has_path(part_route): + raise ValueError("Can't find path for {}".format(part_route)) + + new_a, new_b = part_route[0], part_route[-1] + sub_jobs.append((new_a, new_b)) + return sub_jobs + + +def schedule(graph, start, jobs): + """ + The best possible path is a circuit. + First we'll find all circuits and attempt to remove them from + the equation. + Once no more circuits can be found, the best solution is to look for + alternative combinations that provide improvement. + :return: + """ + new_schedule = [] + jobs_to_plan = jobs[:] + while jobs_to_plan: + circuit_path = find_perfect_circuit(graph=graph, start=start, jobs=jobs_to_plan) + if circuit_path: + job_sequence = jobs_from_path(circuit_path) + else: # circuit not possible. + shortest_path = [] + shortest_distance = float('inf') + for perm in itertools.permutations(jobs_to_plan, len(jobs_to_plan)): + path = path_from_schedule(jobs=perm, start=start) + distance = graph.distance_from_path(path) + if distance < shortest_distance: + shortest_distance = distance + shortest_path = path + job_sequence = jobs_from_path(shortest_path) + # remove planned jobs from options: + for job in job_sequence: + if job in jobs_to_plan: + jobs_to_plan.remove(job) + new_schedule.append(job) + return new_schedule + + +def jobs_from_path(path): + """ helper for finding jobs from path""" + return [(path[i], path[i + 1]) for i in range(len(path) - 1)] + + +def path_from_schedule(jobs, start): + """ The evaluation is based on building the travel path. + For example in the network A,B,C with 4 trips as: + 1 (A,B), 2 (A,C), 3 (B,A), 4 (C,A) + which have the travel path: [A,B,A,C,B,A,C,A] + The shortest path for these jobs is: [A,C,A,B,A] which uses the order: + 2 (A,C), 4 (C,A), 1 (A,B), 3(B,A) + """ + path = [start] + for A, B in jobs: + if A != path[-1]: + path.append(A) + path.append(B) + return path + + +def find_perfect_circuit(graph, start, jobs): + """ A perfect circuit is a path that starts and ends at the same place + and where every movement includes a job. + :param: start: starting location. + :param: jobs: list of movements [(A1,B1), (A2,B2,) ....] + :return path [A1,B1, ..., A1] + """ + G = type(graph) + g = G() + for A, B in jobs: + try: + g.edge(A, B) + except KeyError: + d, p = graph.shortest_path(A, B) + g.add_edge(A, B, d) + + new_starts = [B for A, B in jobs if A == start] + for A in new_starts: + if A in g: + p = g.breadth_first_search(A, start) # path back to start. + if p: + return [start] + p + return [] + diff --git a/graph-theory/source/graph/tsp.py b/graph-theory/source/graph/tsp.py new file mode 100644 index 0000000000000000000000000000000000000000..41991daf9d5779f22947ebbfadc2eddb490e4154 --- /dev/null +++ b/graph-theory/source/graph/tsp.py @@ -0,0 +1,359 @@ +from sys import maxsize +from itertools import combinations, permutations +from collections import Counter +from .base import BasicGraph +from bisect import insort +from random import shuffle + + +def tsp_branch_and_bound(graph): + """ + Solve the traveling salesman's problem for the graph. + :param graph: instance of class Graph + :return: tour_length, path + solution quality 100% + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + def lower_bound(graph, nodes): + """Calculates the lower bound of distances for given nodes.""" + L = [] + edges = set() + for n in nodes: + L2 = [(d, e) for s, e, d in graph.edges(from_node=n) if e in nodes - {n}] + if not L2: + continue + L2.sort() + + for d, n2 in L2: + if (n2, n) in edges: # Solution is not valid as it creates a loop. + continue + else: + edges.add((n, n2)) # remember! + L.append((n, n2, d)) + break + + return L + + global_lower_bound = sum(d for n, n2, d in lower_bound(graph, set(graph.nodes()))) + + q = [] + all_nodes = set(graph.nodes()) + + # create initial tree. + start = graph.nodes()[0] + for start, end, distance in graph.edges(from_node=start): + lb = lower_bound(graph, all_nodes - {start}) + dist = sum(d for s, e, d in lb) + insort( + q, + ( + distance + dist, # lower bound of distance. + -2, # number of nodes in tour. + (start, end), + ), # locations visited. + ) + + hit, switch, q2 = 0, True, [] + while q: # walk the tree. + d, _, tour = q.pop(0) + tour_set = set(tour) + + if tour_set == all_nodes: + if hit < len(all_nodes): # to overcome premature exit. + hit += 1 + insort(q2, (d, tour)) + continue + else: + d, tour = q2.pop(0) + assert d >= global_lower_bound, "Solution not possible." + return d, list(tour[:-1]) + + remaining_nodes = all_nodes - tour_set + + for n2 in remaining_nodes: + new_tour = tour + (n2,) + + lb_set = remaining_nodes - {n2} + if len(lb_set) > 1: + lb_dists = lower_bound(graph, lb_set) + lb = sum(d for n, n2, d in lb_dists) + new_lb = graph.distance_from_path(new_tour) + lb + elif len(lb_set) == 1: + last_node = lb_set.pop() + new_tour = new_tour + (last_node, tour[0]) + new_lb = graph.distance_from_path(new_tour) + else: + raise Exception("bad logic!") + + insort(q, (new_lb, -len(new_tour), new_tour)) + + return float("inf"), [] # <-- exit path if not solvable. + + +def tsp_greedy(graph): + """ + Solves the traveling salesman's problem for the graph. + Runtime approximation: seconds = 10**(-5) * (nodes)**2.31 + Solution quality: Range 98.1% - 100% optimal. + :param graph: instance of class Graph + :return: tour_length, path + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + t1 = _greedy(graph) + d1 = graph.distance(t1) + t2 = _opt2(graph, t1) + d2 = graph.distance(t2) + + if d1 >= d2: # shortest path wins. + return d2, t2 + else: + return d1, t1 + + +# TSP 2023 ---- + + +def _join_endpoints(endpoints, a, b): + """Join segments [...,a] + [b,...] into one segment. Maintain `endpoints`. + :param endpoints: + :param a: node + :param b: node + :return: + """ + a_seg, b_seg = endpoints[a], endpoints[b] + if a_seg[-1] is not a: + a_seg.reverse() + if b_seg[0] is not b: + b_seg.reverse() + a_seg += b_seg + del endpoints[a] + del endpoints[b] + endpoints[a_seg[0]] = endpoints[a_seg[-1]] = a_seg + return a_seg + + +def _greedy(graph): + c = combinations(graph.nodes(), 2) + distances = [(graph.edge(a, b), a, b) for a, b in c if graph.edge(a, b)] + distances.sort() + + new_segment = [] + endpoints = {n: [n] for n in graph.nodes()} + for _, a, b in distances: + if a in endpoints and b in endpoints and endpoints[a] != endpoints[b]: + new_segment = _join_endpoints(endpoints, a, b) + if len(new_segment) == len(graph.nodes()): + break # return new_segment + + if len(new_segment) != len(graph.nodes()): + raise ValueError("there's an unconnected component in the graph.") + return tuple(new_segment) + + +def _opt1(graph, tour): + """Iterative improvement based on relocation.""" + + d_best = graph.distance(tour, return_to_start=True) + p_best = tour + L = tuple(tour) + for i in range(len(tour)): + tmp = L[:i] + L[i + 1 :] + for j in range(len(tour)): + L2 = tmp[:j] + (L[i],) + tmp[j:] + d = graph.distance(L2, return_to_start=True) + if d < d_best: + d_best = d + p_best = tuple(L2) + + tour = p_best + + # TODO: link swop + # distances = [(graph.edge(tour[i], tour[i + 1]), i, i + 1) for i in range(len(tour)-1)] + # distances.sort(reverse=True) # longest link first. + + # for d1, i in distances: + # for j in range(len(tour)): + # if i == j: + # continue + # a, b = tour[i], tour[j] + + # options = sorted([(d2, e) for _, e, d2 in graph.edges(from_node=a) if d2 < d1 and e != b]) + # for d2, e in options: + # ix_e = tour.index(e) + # tmp = tour[32345678] + + # for i in range(len(tour)): + # tmp = p_best[:] + # for j in range(len(tour)): + # if i == j: + # continue + + return tuple(p_best) + + +def _opt2(graph, tour): + """Iterative improvement based on 2 exchange.""" + + def reverse_segment_if_improvement(graph, tour, i, j): + """If reversing tour[i:j] would make the tour shorter, then do it.""" + # Given tour [...a,b...c,d...], consider reversing b...c to get [...a,c...b,d...] + a, b, c, d = tour[i - 1], tour[i], tour[j - 1], tour[j % len(tour)] + # are old links (ab + cd) longer than new ones (ac + bd)? if so, reverse segment. + ab, cd, ac, bd = graph.edge(a, b), graph.edge(c, d), graph.edge(a, c), graph.edge(b, d) + # if all are not None and improvement is shorter than previous ... + if all((ab, cd, ac, bd)) and ab + cd > ac + bd: + tour[i:j] = reversed(tour[i:j]) # ..retain the solution. + return True + + def _zipwalk(tour): + return [(tour[i - 1], tour[i]) for i in range(len(tour))] + + tour = list(tour) + n = len(tour) + g = tuple((i, i + length) for length in reversed(range(2, n)) for i in reversed(range(n - length + 1))) + + counter, c2, inc = Counter(), {}, 0 + p0, d0 = tuple(tour), sum(graph.edge(a, b) for a, b in _zipwalk(tour)) + counter[p0] += 1 + + while True: + improvements = {reverse_segment_if_improvement(graph, tour, i, j) for (i, j) in g} + + d1 = sum(graph.edge(a, b) for a, b in _zipwalk(tour)) + if d1 < d0: + d0 = d1 + p0 = tour[:] + + if improvements == {None} or len(improvements) == 0: + break + + counter[tuple(tour)] += 1 + inc += 1 + + if inc % 100 == 0: + if any(v > 2 for v in counter.values()): + break + return tuple(p0) + + +def _opt3(graph, tour): + """Iterative improvement based on 3 exchange.""" + + def distance(a, b, graph=graph): + return graph.edge(a, b, default=maxsize) + + def _zipwalk(tour): + return [(tour[i - 1], tour[i]) for i in range(len(tour))] + + def reverse_segment_if_better(graph, tour, i, j, k): + """If reversing tour[i:j] would make the tour shorter, then do it.""" + distance = lambda a, b: graph.edge(a, b, default=maxsize) + + # Given tour [...A-B...C-D...E-F...] + A, B, C, D, E, F = tour[i - 1], tour[i], tour[j - 1], tour[j], tour[k - 1], tour[k % len(tour)] + dmin, mindex = maxsize, "" + d0 = distance(A, B) + distance(C, D) + distance(E, F) + dmin, mindex = d0, "d0" + d1 = distance(A, C) + distance(B, D) + distance(E, F) + if d1 < dmin: + dmin, mindex = d1, "d1" + d2 = distance(A, B) + distance(C, E) + distance(D, F) + if d2 < dmin: + dmin, mindex = d2, "d2" + d3 = distance(A, D) + distance(E, B) + distance(C, F) + if d3 < dmin: + dmin, mindex = d3, "d3" + d4 = distance(F, B) + distance(C, D) + distance(E, A) + if d4 < dmin: + dmin, mindex = d4, "d4" + + if mindex == "d0": + return 0 + if mindex == "d1": + tour[i:j] = reversed(tour[i:j]) + return -d0 + d1 + elif mindex == "d2": + tour[j:k] = reversed(tour[j:k]) + return -d0 + d2 + elif mindex == "d3": + tmp = tour[j:k] + tour[i:j] + tour[i:k] = tmp + return -d0 + d3 + else: # elif mindex == "d4": + tour[i:k] = reversed(tour[i:k]) + return -d0 + d4 + + def all_segments(n: int): + """Generate all segments combinations""" + return ((i, j, k) for i in range(n) for j in range(i + 2, n) for k in range(j + 2, n + (i > 0))) + + tour = list(tour) + p0, d0 = tour[:], sum(graph.edge(a, b) for a, b in _zipwalk(tour)) + counter, inc = Counter(), 0 + while True: + delta = 0 + for a, b, c in all_segments(len(tour)): + delta += reverse_segment_if_better(graph, tour, a, b, c) + + d1 = sum(graph.edge(a, b) for a, b in _zipwalk(tour)) + if d1 < d0: + d0 = d1 + p0 = tour[:] + + if delta >= 0: + break + + inc += 1 + if inc % 100 == 0: + if any(v > 2 for v in counter.values()): + break + return tuple(p0) + + +def brute_force(graph): + d2 = maxsize + nodes = graph.nodes() + for route in permutations(nodes, len(nodes)): + if route[0] != nodes[0]: # all iterations after this point are rotations. + break + route += (route[0],) + d = graph.distance_from_path(route) + if d < d2: + d2 = d + p2 = route[:-1] + return d2, tuple(p2) + + +def tsp_2023(graph): + """ + TSP-2023 is the authors implementation of best practices discussed in Frontiers in Robotics and AI + read more: https://www.frontiersin.org/articles/10.3389/frobt.2021.689908/full + + Args: + graph (BasicGraph): fully connected subclass of BasicGraph + """ + if not isinstance(graph, BasicGraph): + raise TypeError(f"Expected subclass of BasicGraph, not {type(graph)}") + + if len(graph.nodes()) < 7: + return brute_force(graph) + + t = _greedy(graph) + d = graph.distance(t) + + t1 = _opt1(graph, t) + d1 = graph.distance(t1) + + t2 = _opt2(graph, t1) + d2 = graph.distance(t2) + + t3 = _opt3(graph, t2) + d3 = graph.distance(t3) + + L = [(d, t), (d1, t1), (d2, t2), (d3, t3)] + L.sort() + return L[0] diff --git a/graph-theory/source/graph/version.py b/graph-theory/source/graph/version.py new file mode 100644 index 0000000000000000000000000000000000000000..0e370063cddaeaaf5b31b305e20bb49516485c4e --- /dev/null +++ b/graph-theory/source/graph/version.py @@ -0,0 +1,3 @@ +major, minor, patch = 2023, 7, 8 +__version_info__ = (major, minor, patch) +__version__ = ".".join(str(i) for i in __version_info__) diff --git a/graph-theory/source/graph/visuals.py b/graph-theory/source/graph/visuals.py new file mode 100644 index 0000000000000000000000000000000000000000..05bf0fe9b571eac4f8e8f7f5f4fbec89da32f82d --- /dev/null +++ b/graph-theory/source/graph/visuals.py @@ -0,0 +1,156 @@ +try: + from matplotlib import pyplot as plt + from mpl_toolkits.mplot3d import Axes3D # import required by matplotlib. + + visuals_enabled = True +except ImportError: + visuals_enabled = False + import warnings + warnings.warn("matplotlib is not installed, visuals are disabled. Please install matplotlib>=3.1.0") + + +def visualise(func): + def wrapper(*args, **kwargs): + if not visuals_enabled: + raise ImportError("visualise is not available unless matplotlib is installed") + return func(*args, **kwargs) + + return wrapper + + +@visualise +def plot_2d(graph, nodes=True, edges=True): + """ + :param graph: instance of Graph with nodes as (x,y) + :param nodes: bool: plots nodes + :param edges: bool: plots edges + :return: matlibplot.pyplot + + PRO-TIP: If your graph does not have nodes as (x,y) use random_xy_graph to + create it with this recipe: + + Step 1: Get the imports. + >>> from graph.random import random_xy_graph + >>> from graph.hash import graph_hash + + Step 2: Determine the initialisation values. + >>> node_count = len(graph.nodes()) + >>> seed = graph_hash(graph) + >>> x_max = node_count * 8 + >>> y_max = node_count * 4 + >>> xygraph = random_xy_graph(node_count, x_max, y_max, edges=0, seed=seed) + + Step 3: create a mapping between the xy graph and the original graph. + >>> mapping = {a:b for a,b in zip(xygraph.nodes(), graph.nodes())} + + Step 4: add the edges: + >>> for edge in graph.edges(): + >>> start, end, distance = edge + >>> xygraph.add_edge(mapping[start], mapping[end], distance) + >>> plt = xygraph.plot_2d() + >>> plt.show() + + """ + assert isinstance(nodes, bool) + assert isinstance(edges, bool) + + for node in graph.nodes(): + if not isinstance(node, tuple): + raise ValueError(f"expected graph.nodes() to be tuple(x,y), but found {node}") + if not len(node) == 2: + raise ValueError(f"expected tuples have 2 values, but found {node} (len={len(node)})") + x, y = node + if not isinstance(x, (float, int)): + raise ValueError(f"expected node in graph.nodes() to have (x,y) as float or int, but got {type(x)}") + if not isinstance(y, (float, int)): + raise ValueError(f"expected node in graph.nodes() to have (x,y) as float or int, but got {type(y)}") + + plt.figure() + if nodes: + xs, ys = [a[0] for a in graph.nodes()], [a[1] for a in graph.nodes()] + plt.plot(xs, ys) + + if edges: + for edge in graph.edges(): + s, e, d = edge # s: (x1,y1), e: (x2,y2), d: distance + plt.plot([s[0], e[0]], [s[1], e[1]], "bo-", clip_on=False) + + plt.axis("scaled") + plt.axis("off") + return plt + + +@visualise +def plot_3d(graph, nodes=True, edges=True, rotation="xyz", maintain_aspect_ratio=False): + """plots nodes and links using matplotlib3 + :param nodes: bool: plots nodes + :param edges: bool: plots edges + :param rotation: str: set view point as one of [xyz,xzy,yxz,yzx,zxy,zyx] + :param maintain_aspect_ratio: bool: rescales the chart to maintain aspect ratio. + :return: matlibplot.pyplot + """ + fig = plt.figure() + ax = fig.add_subplot(111, projection="3d") + if not len(rotation) == 3: + raise ValueError(f"expected viewpoint as 'xyz' but got: {rotation}") + for c in "xyz": + if c not in rotation: + raise ValueError(f"rotation was missing {c}.") + x, y, z = rotation + + # Data for a three-dimensional line + if edges: + for edge in graph.edges(): + n1, n2, v = edge + xyz = dict() + xyz[x] = [n1[0], n2[0]] + xyz[y] = [n1[1], n2[1]] + xyz[z] = [n1[2], n2[2]] + ax.plot3D(xyz["x"], xyz["y"], xyz["z"], "gray") + + # Data for three-dimensional scattered points + if nodes: + xyz = {x: [], y: [], z: []} + ix = [] + for idx, node in enumerate(graph.nodes()): + vx, vy, vz = node # value of ... + xyz[x].append(vx) + xyz[y].append(vy) + xyz[z].append(vz) + ix.append(idx) + ax.scatter3D(xyz["x"], xyz["y"], xyz["z"], c=ix, cmap="Greens") + + if (nodes or edges) and maintain_aspect_ratio: + nodes = [n for n in graph.nodes()] + xyz_dir = {"x": 0, "y": 1, "z": 2} + + xdim = xyz_dir[x] # select the x dimension in the projection. + # as the rotation will change the xdimension index. + xs = [n[xdim] for n in nodes] # use the xdim index to obtain the values. + xmin, xmax = min(xs), max(xs) + dx = (xmax + xmin) / 2 # determine the midpoint for the dimension. + + ydim = xyz_dir[y] + ys = [n[ydim] for n in nodes] + ymin, ymax = min(ys), max(ys) + dy = (ymax + ymin) / 2 + + zdim = xyz_dir[z] + zs = [n[zdim] for n in nodes] + zmin, zmax = min(zs), max(zs) + dz = (zmax + zmin) / 2 + + # calculate the radius for the aspect ratio. + max_dim = max([xmax - xmin, ymax - ymin, zmax - zmin]) / 2 + + xa, xb = dx - max_dim, dx + max_dim # lower, uppper + ax.set_xlim(xa, xb) # apply the lower and upper to the axis. + ya, yb = dy - max_dim, dy + max_dim + ax.set_ylim(ya, yb) + za, zb = dz - max_dim, dz + max_dim + ax.set_zlim(za, zb) + + ax.set_xlabel(f"{x} Label") + ax.set_ylabel(f"{y} Label") + ax.set_zlabel(f"{z} Label") + return plt diff --git a/graph-theory/source/requirements.txt b/graph-theory/source/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/graph-theory/source/setup.py b/graph-theory/source/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..e3a26ca455d1fa857c006e891f1720a7f8cf103c --- /dev/null +++ b/graph-theory/source/setup.py @@ -0,0 +1,130 @@ +""" +graph-theory +""" +from setuptools import setup +from pathlib import Path + + +root = Path(__file__).parent + +__version__ = None +version_file = root / "graph" / "version.py" +exec(version_file.read_text()) +assert isinstance(__version__, str) # noqa + +with open(root / "README.md", encoding="utf-8") as f: + long_description = f.read() + +with open(root / "requirements.txt", "r", encoding="utf-8") as fi: + requirements = [v.rstrip("\n") for v in fi.readlines()] + +keywords = list( + { + "complex-networks", + "discrete mathematics", + "graph", + "Graph Theory", + "graph-algorithms", + "graph-analysis", + "analysis", + "algorithms", + "graph-generation", + "graph-theory", + "graph-visualization", + "graphs", + "math", + "Mathematics", + "maths", + "generation", + "generate", + "theory", + "minimum-spanning-trees", + "network", + "Networks", + "optimization", + "python", + "shortest-path", + "tsp", + "tsp-solver", + "minimum", + "spanning", + "tree", + "assignment problem", + "flow-problem", + "hash", + "graph-hash", + "random graph", + "search", + "cycle", + "path", + "flow", + "path", + "shortest", + "component", + "components", + "adjacency", + "matrix", + "all pairs shortest path", + "finite state machine", + "fsm", + "adjacent", + "pairs", + "finite", + "state", + "machine", + "traffic-jam", + "traffic-jam-solver", + "solver", + "hill-climbing", + "simple", + "simple-path", + "critical", + "path", + "congestions", + "jam", + "traffic", + "optimisation", + "method", + "critical-path", + "minimize", + "minimise", + "optimize", + "optimise", + "merkle", + "tree", + "merkle-tree", + "hash-tree", + } +) + +keywords.sort(key=lambda x: x.lower()) + + +setup( + name="graph-theory", + version=__version__, + url="https://github.com/root-11/graph-theory", + license="MIT", + author="https://github.com/root-11", + description="A graph library", + long_description=long_description, + long_description_content_type="text/markdown", + keywords=keywords, + packages=["graph"], + python_requires=">=3.8", + include_package_data=True, + data_files=[(".", ["LICENSE", "README.md", "requirements.txt"])], + platforms="any", + install_requires=requirements, + classifiers=[ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Science/Research", + "Natural Language :: English", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + ], +) diff --git a/graph-theory/source/test-requirements.txt b/graph-theory/source/test-requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..be518ef3934c58d02f96db9ab0973745f2aaf4af --- /dev/null +++ b/graph-theory/source/test-requirements.txt @@ -0,0 +1,2 @@ +pytest >= 7 +matplotlib >= 3.1 \ No newline at end of file diff --git a/graph-theory/source/tests/__init__.py b/graph-theory/source/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..55820ff91c101dce849bc4cd1d99457e224d972e --- /dev/null +++ b/graph-theory/source/tests/__init__.py @@ -0,0 +1,25 @@ +import cProfile +import io +import pstats + + +def profileit(func): + """ decorator for profiling function. + usage: + >>> def this(var1, var2): + # do something + + >>> new_this = profileit(this) + >>> calls, cprofile_text = new_this(var1=1,var2=2) + """ + def wrapper(*args, **kwargs): + prof = cProfile.Profile() + retval = prof.runcall(func, *args, **kwargs) + s = io.StringIO() + sortby = 'cumulative' + ps = pstats.Stats(prof, stream=s).sort_stats(sortby) + ps.print_stats() + text = s.getvalue() + calls = int(text.split('\n')[0].lstrip().split(" ")[0]) + return calls, text + return wrapper diff --git a/graph-theory/source/tests/test_assignment_problem.py b/graph-theory/source/tests/test_assignment_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..90e5c77f69379ef14abe00668c1e0d69010e1e41 --- /dev/null +++ b/graph-theory/source/tests/test_assignment_problem.py @@ -0,0 +1,95 @@ +from itertools import permutations + +from graph import Graph +from graph.assignment_problem import ap_solver + + +def test_01_taxis_and_customers(): + """ Test where taxis are assigned to customers, so that the + time to travel is minimised. + + Note that the travel time is negative, whereby the optimal + assignment will have the minimal reponse time for all taxis + to collect all customers. + + """ + taxis = [1, 2, 3] + customers = [4, 5, 6] + # relationships with distance as minutes apart. + L = [ + (1, 4, -11), # taxi 1, customer 4, 11 minutes apart. + (1, 5, -23), + (1, 6, -33), + (2, 4, -14), + (2, 5, -17), + (2, 6, -34), + (3, 4, -22), + (3, 5, -19), + (3, 6, -13) + ] + relationships = Graph(from_list=L) + + permutations_checked = 0 + for taxis_ in permutations(taxis, len(taxis)): + for customers_ in permutations(customers, len(customers)): + permutations_checked += 1 + print(permutations_checked, taxis_, customers_) + assignment = ap_solver(graph=relationships) + assert set(assignment) == {(1, 4, -11), (2, 5, -17), (3, 6, -13)} + assert sum(v for a, t, v in assignment) == sum([-11, -17, -13]) + print("The assignment problem solver is insensitive to initial conditions.") + + +def test_02_taxis_and_more_customers(): + """ + Like test_01, but with an additional customer who is attractive + (value = -10) + + The same conditions exist as in test_01, but the least attractice + customer (5) with value -17 is expected to be dropped. + """ + L = [ + (1, 4, -11), # taxi 1, customer 4, 11 minutes apart. + (1, 5, -23), + (1, 6, -33), + (1, 7, -10), + (2, 4, -14), + (2, 5, -17), + (2, 6, -34), + (2, 7, -10), + (3, 4, -22), + (3, 5, -19), + (3, 6, -13), + (3, 7, -10) + ] + relationships = Graph(from_list=L) + assignment = ap_solver(graph=relationships) + assert set(assignment) == {(1, 7, -10), (2, 4, -14), (3, 6, -13)} + assert sum(v for a, t, v in assignment) > sum([-11, -17, -13]) + + +def test_03_taxis_but_fewer_customers(): + """ + Like test_01, but with an additional taxi who is more attractive. + + We hereby expect that the new taxi (7) will steal the customer + from 2. + """ + L = [ + (1, 4, -11), # taxi 1, customer 4, 11 minutes apart. + (1, 5, -23), + (1, 6, -33), + (2, 4, -14), + (2, 5, -17), + (2, 6, -34), + (3, 4, -22), + (3, 5, -19), + (3, 6, -13), + (7, 4, -11), + (7, 5, -11), + (7, 6, -11), + ] + relationships = Graph(from_list=L) + assignment = ap_solver(graph=relationships) + assert set(assignment) == {(1, 4, -11), (2, 5, -17), (7, 6, -11)} + assert sum(v for a, t, v in assignment) > sum([-11, -17, -13]) \ No newline at end of file diff --git a/graph-theory/source/tests/test_basics.py b/graph-theory/source/tests/test_basics.py new file mode 100644 index 0000000000000000000000000000000000000000..73d73c834cb5a644bc1c2133b78777cb00c5f3d2 --- /dev/null +++ b/graph-theory/source/tests/test_basics.py @@ -0,0 +1,399 @@ +from graph import Graph +from tests.test_graph import graph3x3, graph01, graph05, graph_cycle_6, graph_cycle_5 + + +def test_to_from_dict(): + d = {1: {2: 10, 3: 5}, + 2: {4: 1, 3: 2}, + 3: {2: 3, 4: 9, 5: 2}, + 4: {5: 4}, + 5: {1: 7, 4: 6}, + 6: {}} + g = Graph() + g.from_dict(d) + d2 = g.to_dict() + assert d == d2 + + +def test_setitem(): + g = Graph() + try: + g[1][2] = 3 + raise ValueError("Assignment is not permitted use g.add_edge instead.") + except ValueError: + pass + g.add_node(1) + try: + g[1][2] = 3 + raise ValueError + except ValueError: + pass + g.add_edge(1, 2, 3) + assert g.edges() == [(1, 2, 3)] + link_1 = g.edge(1, 2) + assert link_1 == 3 + link_1 = g.edge(1, 2) + assert link_1 == 3 + link_1 = 4 # attempt setattr. + assert g.edge(1, 2) != 4 # the edge is not an object. + g.add_edge(1, 2, 4) + assert g.edges() == [(1, 2, 4)] + + g = Graph() + try: + g[1] = {2: 3} + raise ValueError + except ValueError: + pass + + +def test_add_node_attr(): + g = graph3x3() + g.add_node(1, "this") + assert set(g.nodes()) == set(range(1, 10)) + node_1 = g.node(1) + assert node_1 == "this" + + d = {"This": 1, "That": 2} + g.add_node(1, obj=d) + assert g.node(1) == d + + rm = 5 + g.del_node(rm) + for n1, n2, d in g.edges(): + assert n1 != rm and n2 != rm + g.del_node(rm) # try again for a node that doesn't exist. + + +def test_add_edge_attr(): + g = Graph() + try: + g.add_edge(1, 2, {'a': 1, 'b': 2}) + raise Exception("Assignment of non-values is not supported.") + except ValueError: + pass + + +class MyCustomHashableNode(): + def __init__(self, name): + self.name = name + + def __hash__(self): + return hash(self.name) + + def __eq__(self, other): + """ note that without __eq__ this wont work. + https://stackoverflow.com/questions/9010222/why-can-a-python-dict-have-multiple-keys-with-the-same-hash?noredirect=1&lq=1 + """ + return hash(self) == hash(other) + + +def test_node_types(): + for test in [ + [1, 2, 1, 3], + ['A', 'B', 'A', 'C'], + [MyCustomHashableNode(i) for i in ['A', 'B', 'A', 'C']], + ]: + a,b,c,d = test + g = Graph() + g.add_edge(a,b,10) + g.add_edge(c,d,10) + assert len(g.nodes()) == 3 + + +def test_to_list(): + g1 = graph01() + g1.add_node(44) + g2 = Graph(from_list=g1.to_list()) + assert g1.edges() == g2.edges() + assert g1.nodes() == g2.nodes() + + +def test_bidirectional_link(): + g = Graph() + g.add_edge(node1=1, node2=2, value=4, bidirectional=True) + assert g.edge(1, 2) == g.edge(2, 1) + + +def test_edges_with_node(): + g = graph3x3() + edges = g.edges(from_node=5) + assert set(edges) == {(5, 6, 1), (5, 8, 1)} + assert g.edge(5, 6) == 1 + assert g.edge(5, 600) is None # 600 doesn't exist. + + +def test_nodes_from_node(): + g = graph3x3() + nodes = g.nodes(from_node=1) + assert set(nodes) == {2, 4} + nodes = g.nodes(to_node=9) + assert set(nodes) == {6, 8} + nodes = g.nodes() + assert set(nodes) == set(range(1, 10)) + + try: + _ = g.nodes(in_degree=-1) + assert False + except ValueError: + assert True + + nodes = g.nodes(in_degree=0) + assert set(nodes) == {1} + nodes = g.nodes(in_degree=1) + assert set(nodes) == {2, 3, 4, 7} + nodes = g.nodes(in_degree=2) + assert set(nodes) == {5, 6, 8, 9} + nodes = g.nodes(in_degree=3) + assert nodes == [] + + try: + _ = g.nodes(out_degree=-1) + assert False + except ValueError: + assert True + + nodes = g.nodes(out_degree=0) + assert set(nodes) == {9} + + g.add_node(44) + assert set(g.nodes(out_degree=0)) == {9, 44} + + nodes = g.nodes(out_degree=1) + assert set(nodes) == {3, 6, 7, 8} + nodes = g.nodes(out_degree=2) + assert set(nodes) == {1, 2, 4, 5} + nodes = g.nodes(out_degree=3) + assert nodes == [] + + try: + _ = g.nodes(in_degree=1, out_degree=1) + assert False + except ValueError: + assert True + + +def test01(): + """ + Asserts that the shortest_path is correct + """ + g = graph01() + dist, path = g.shortest_path(1, 4) + assert [1, 3, 2, 4] == path, path + assert 9 == dist, dist + + +def test02(): + """ + Assert that the dict loader works. + """ + d = {1: {2: 10, 3: 5}, + 2: {4: 1, 3: 2}, + 3: {2: 3, 4: 9, 5: 2}, + 4: {5: 4}, + 5: {1: 7, 4: 6}} + g = Graph(from_dict=d) + assert 3 in g + assert d[3][4] == g.edge(3, 4) + + +def test03(): + g = graph3x3() + all_edges = g.edges() + edges = g.edges(path=[1, 2, 3, 6, 9]) + for edge in edges: + assert edge in all_edges, edge + + +def test_subgraph(): + g = graph3x3() + g2 = g.subgraph_from_nodes([1, 2, 3, 4]) + d = {1: {2: 1, 4: 1}, + 2: {3: 1}, + } + assert g2.is_subgraph(g) + for k, v in d.items(): + for k2, d2 in v.items(): + assert g.edge(k, k2) == g2.edge(k, k2) + + g3 = graph3x3() + g3.add_edge(3, 100, 7) + assert not g3.is_subgraph(g2) + + +def test_in_and_out_degree(): + g = graph3x3() + + in_degree = {1: 0, 2: 1, 3: 1, 4: 1, 5: 2, 6: 2, 7: 1, 8: 2, 9: 2} + out_degree = {1: 2, 2: 2, 3: 1, 4: 2, 5: 2, 6: 1, 7: 1, 8: 1, 9: 0} + for node in g.nodes(): + assert g.in_degree(node) == in_degree[node] + assert g.out_degree(node) == out_degree[node] + +def test_equals(): + g1 = Graph(from_list=[(1,2),(2,3)]) + g2 = g1.copy() + assert g1 == g2 + + g1.add_edge(3,1) + g1.del_edge(3,1) + assert g1 == g2 + + assert g1.edges() == g2.edges() + assert g1.nodes() == g2.nodes() + +def test_equals_2(): + g1 = Graph(from_list=[(1,2),(2,3)]) + g2 = Graph(from_list=[(1,2),(2,3)]) + _ = g1.edge(3,1) # simple getter. + assert g1._edges == g2._edges + assert g1 == g2 + + +def test_copy_equals(): + g1 = Graph(from_list=[(1,2),(2,3)]) + g1.add_edge(3,1) + g1.del_edge(3,1) + g2 = g1.copy() + assert g1 == g2 + + +def test_copy_equals_2(): + g1 = Graph(from_list=[(1,2),(2,3)]) + g1.edge(3,1) + g2 = g1.copy() + assert g1 == g2 + assert g1._edges == g2._edges + assert g1._edges is not g2._edges, "the two graphs must be independent" + assert g1._edge_count == g2._edge_count + + +def test_copy(): + g = graph05() + g2 = g.copy() + assert set(g.edges()) == set(g2.edges()) + assert g == g2, "testing == operator failed" + g2.add_node(1, "this") + + g3 = Graph(from_list=g.to_list()) + assert g2 != g3 + g2.add_node(1) + assert g2 == g3 + + +def test_errors(): + g = graph05() + try: + len(g) + raise AssertionError + except ValueError: + assert True + + try: + g.edges(from_node=1, to_node=1) + raise AssertionError + except ValueError: + assert True + + try: + g.edges(path=[1]) + raise AssertionError + except ValueError: + assert True + + try: + g.edges(path="this") + raise AssertionError + except ValueError: + assert True + + e = g.edges(from_node=77) + assert e == [] + + +def test_delitem(): + g = graph05() + + try: + g.__delitem__(key=1) + assert False + except ValueError: + assert True + + g.del_edge(node1=0, node2=1) + g.del_edge(0, 1) # idempotent. + + v = g.edge(0, 1) + if v is not None: + raise ValueError + v = g.edge(0, 1, default=44) + if v != 44: + raise ValueError + + +def test_is_partite(): + g = graph_cycle_6() + bol, partitions = g.is_partite(n=2) + assert bol is True + + g = graph_cycle_5() + bol, part = g.is_partite(n=2) + assert bol is False + bol, part = g.is_partite(n=5) + assert bol is True + assert len(part) == 5 + + +def test_is_cyclic(): + g = graph_cycle_5() + assert g.has_cycles() + + +def test_is_not_cyclic(): + g = graph3x3() + assert not g.has_cycles() + + +def test_is_really_cyclic(): + g = Graph(from_list=[(1, 1, 1), (2, 2, 1)]) # two loops onto themselves. + assert g.has_cycles() + + +def test_no_edge_connected(): + g = Graph() + g.add_node(4) + g.add_node(5) + assert g.is_connected(4, 5) is False + + +def test_edge_connected(): + g = Graph() + g.add_edge(4, 5) + assert g.is_connected(4, 5) is True + + +def test_edge_not_connected(): + g = Graph() + g.add_edge(3, 4) + g.add_edge(5, 4) + assert g.is_connected(3, 5) is False + + +def test_del_edge(): + the_sort = [] + g = Graph() + g.add_edge(1, 2) + g.add_edge(2, 3) + zero_in = g.nodes(in_degree=0) + while zero_in: + for n in zero_in: + the_sort.append(n) + g.del_node(n) + zero_in = g.nodes(in_degree=0) + assert len(g.nodes()) == 0 + assert len(g._nodes) == 0 + assert len(g._edges) == 0 + assert len(g._reverse_edges) == 0 + assert len(g._in_degree) == 0 + assert len(g._out_degree) == 0 + diff --git a/graph-theory/source/tests/test_facility_location_problem.py b/graph-theory/source/tests/test_facility_location_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..8df740dfb31eeb8adf99fa2b60cb7b56394e9ffa --- /dev/null +++ b/graph-theory/source/tests/test_facility_location_problem.py @@ -0,0 +1,32 @@ +from examples.graphs import london_underground + +""" +The problem of deciding the exact place in a community where a school or a fire station should be located, +is classified as the facility location problem. + +If the facility is a school, it is desirable to locate it so that the sum +of distances travelled by all members of the communty is as short as possible. +This is the minimum of sum - or in short `minsum` of the graph. + +If the facility is a firestation, it is desirable to locate it so that the distance from the firestation +to the farthest point in the community is minimized. +This is the minimum of max distances - or in short `minmax` of the graph. +""" + + +def test_minsum(): + g = london_underground() + stations = g.minsum() + assert len(stations) == 1 + station_list = [g.node(s) for s in stations] + assert station_list == [(51.515, -0.1415, 'Oxford Circus')] + + +def test_minmax(): + g = london_underground() + stations = g.minmax() + assert len(stations) == 3 + station_list = [g.node(s) for s in stations] + assert station_list == [(51.5226, -0.1571, 'Baker Street'), + (51.5142, -0.1494, 'Bond Street'), + (51.5234, -0.1466, "Regent's Park")] diff --git a/graph-theory/source/tests/test_finite_state_machine.py b/graph-theory/source/tests/test_finite_state_machine.py new file mode 100644 index 0000000000000000000000000000000000000000..cb2af333a5a8739d7deff857da9aae6b48a6b777 --- /dev/null +++ b/graph-theory/source/tests/test_finite_state_machine.py @@ -0,0 +1,91 @@ +from graph.finite_state_machine import FiniteStateMachine +from itertools import cycle + + +def test_traffic_light(): + green, yellow, red = 'Green', 'Yellow', 'Red' + seq = cycle([green, yellow, red]) + _ = next(seq) + fsm = FiniteStateMachine() + fsm.add_transition(green, 'switch', yellow) + fsm.add_transition(yellow, 'switch', red) + fsm.add_transition(red, 'switch', green) + fsm.set_initial_state(green) + for _ in range(20): + current_state = fsm.current_state + new_state = next(seq) + fsm.next('switch') + assert fsm.current_state == new_state, (fsm.current_state, new_state) + assert new_state != current_state, (new_state, current_state) + + +def test_turnstile(): + locked, unlocked = 'locked', 'unlocked' # states + push, coin = 'push', 'coin' # actions + fsm = FiniteStateMachine() + fsm.add_transition(locked, coin, unlocked) + fsm.add_transition(unlocked, push, locked) + fsm.add_transition(locked, push, locked) + fsm.add_transition(unlocked, coin, unlocked) + try: + assert fsm._initial_state_was_set is False + fsm.next(coin) + raise AssertionError + except ValueError: + pass + + try: + assert fsm._initial_state_was_set is False + fsm.set_initial_state('fish') + raise AssertionError + except ValueError: + pass + + fsm.set_initial_state(locked) + + try: + assert fsm._initial_state_was_set is True + fsm.set_initial_state(locked) + raise AssertionError + except ValueError: + assert fsm._initial_state_was_set is True + pass + + # pay and go: + display_state = set(fsm.options()) + assert display_state == {coin, push}, display_state + assert fsm.current_state == locked + fsm.next(action=coin) + display_state = set(fsm.options()) + assert display_state == {coin, push}, display_state + assert fsm.current_state == unlocked + fsm.next(action=push) + assert fsm.current_state == locked + + # try to cheat + fsm.next(action=push) + assert fsm.current_state == locked + fsm.next(action=push) + assert fsm.current_state == locked + + # pay and go: + fsm.next(action=coin) + assert fsm.current_state == unlocked + fsm.next(action=push) + assert fsm.current_state == locked + + try: + assert fsm._initial_state_was_set is True + fsm.next(action='fish') + raise AssertionError + except ValueError: + pass + + fsm.add_transition(locked, 'fire', 'fire escape mode') + fsm.next('fire') + try: + fsm.next(push) + raise AssertionError + except StopIteration: + pass + diff --git a/graph-theory/source/tests/test_flow_problem.py b/graph-theory/source/tests/test_flow_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..96295f308abd6aa6a5d8e86dbb878ec83d7473a7 --- /dev/null +++ b/graph-theory/source/tests/test_flow_problem.py @@ -0,0 +1,262 @@ +from graph import Graph +from graph.min_cost_flow import minimum_cost_flow_using_successive_shortest_path + + +def test_maximum_flow(): + """ [2] ----- [5] + / + / | + + [1] [4] | [7] + + / + | / + [3] ----- [6] + """ + edges = [ + (1, 2, 18), + (1, 3, 10), + (2, 4, 7), + (2, 5, 6), + (3, 4, 2), + (3, 6, 8), + (4, 5, 10), + (4, 6, 10), + (5, 6, 16), + (5, 7, 9), + (6, 7, 18) + ] + g = Graph(from_list=edges) + + flow, g2 = g.maximum_flow(1, 7) + assert flow == 23, flow + + +def test_min_cut(): + """ [2] ----- [5] + / + / | + + [1] [4] | [7] + + / + | / + [3] ----- [6] + """ + edges = [ + (1, 2, 18), + (1, 3, 18), # different from test_maximum_flow + (2, 4, 7), + (2, 5, 6), + (3, 4, 2), + (3, 6, 8), + (4, 5, 10), + (4, 6, 10), + (5, 6, 16), + (5, 7, 9), + (6, 7, 18) + ] + g = Graph(from_list=edges) + + max_flow_min_cut = g.maximum_flow_min_cut(1,7) + assert set(max_flow_min_cut) == {(2, 5), (2, 4), (3, 4), (3, 6)} + + +def test_maximum_flow01(): + edges = [ + (1, 2, 1) + ] + g = Graph(from_list=edges) + flow, g2 = g.maximum_flow(start=1, end=2) + assert flow == 1, flow + + +def test_maximum_flow02(): + edges = [ + (1, 2, 10), + (2, 3, 1), # bottleneck. + (3, 4, 10) + ] + g = Graph(from_list=edges) + flow, g2 = g.maximum_flow(start=1, end=4) + assert flow == 1, flow + + +def test_maximum_flow03(): + edges = [ + (1, 2, 10), + (1, 3, 10), + (2, 4, 1), # bottleneck 1 + (3, 5, 1), # bottleneck 2 + (4, 6, 10), + (5, 6, 10) + ] + g = Graph(from_list=edges) + flow, g2 = g.maximum_flow(start=1, end=6) + assert flow == 2, flow + + +def test_maximum_flow04(): + edges = [ + (1, 2, 10), + (1, 3, 10), + (2, 4, 1), # bottleneck 1 + (2, 5, 1), # bottleneck 2 + (3, 5, 1), # bottleneck 3 + (3, 4, 1), # bottleneck 4 + (4, 6, 10), + (5, 6, 10) + ] + g = Graph(from_list=edges) + flow, g2 = g.maximum_flow(start=1, end=6) + assert flow == 4, flow + + +def test_maximum_flow05(): + edges = [ + (1, 2, 10), + (1, 3, 1), + (2, 3, 1) + ] + g = Graph(from_list=edges) + flow, g2 = g.maximum_flow(start=1, end=3) + assert flow == 2, flow + + +def test_maximum_flow06(): + edges = [ + (1, 2, 1), + (1, 3, 1), + (2, 4, 1), + (3, 4, 1), + (4, 5, 2), + (5, 6, 1), + (5, 7, 1), + (6, 8, 1), + (7, 8, 1) + ] + g = Graph(from_list=edges) + flow, g2 = g.maximum_flow(start=1, end=8) + assert flow == 2, flow + assert set(g2.edges()) == set(edges) + + +def lecture_23_max_flow_problem(): + """ graph and stock from https://youtu.be/UtSrgTsKUfU """ + edges = [(1, 2, 8), + (1, 3, 6), + (2, 4, 5), + (2, 5, 7), + (3, 4, 6), + (3, 5, 3), + (4, 5, 4)] # s,e,cost/unit + g = Graph(from_list=edges) + stock = {1: 6, 2: 0, 3: 4, 4: -5, 5: -5} # supply > 0 > demand, stock == 0 + return g, stock + + +lec_23_optimum_cost = 81 + + +def test_minimum_cost_flow_successive_shortest_path_unlimited(): + costs, inventory = lecture_23_max_flow_problem() + mcf = minimum_cost_flow_using_successive_shortest_path + total_cost, movements = mcf(costs, inventory) + assert isinstance(movements, Graph) + assert total_cost == lec_23_optimum_cost + expected = [ + (1, 3, 6), + (3, 4, 5), + (3, 5, 5) + ] + for edge in movements.edges(): + expected.remove(edge) # will raise error if edge is missing. + assert expected == [] # will raise error if edge wasn't removed. + + +def test_minimum_cost_flow_successive_shortest_path_plenty(): + costs, inventory = lecture_23_max_flow_problem() + capacity = Graph(from_list=[(s, e, lec_23_optimum_cost) for s, e, d in costs.edges()]) + mcf = minimum_cost_flow_using_successive_shortest_path + total_cost, movements = mcf(costs, inventory, capacity) + assert isinstance(movements, Graph) + assert total_cost == lec_23_optimum_cost + expected = [ + (1, 3, 6), + (3, 4, 5), + (3, 5, 5) + ] + for edge in movements.edges(): + expected.remove(edge) # will raise error if edge is missing. + assert expected == [] # will raise error if edge wasn't removed. + + +def test_minimum_cost_flow_successive_shortest_path_35_constrained(): + costs, inventory = lecture_23_max_flow_problem() + capacity = Graph(from_list=[(s, e, lec_23_optimum_cost) for s, e, d in costs.edges()]) + capacity.add_edge(3, 5, 4) + + mcf = minimum_cost_flow_using_successive_shortest_path + total_cost, movements = mcf(costs, inventory, capacity) + assert isinstance(movements, Graph) + assert total_cost == lec_23_optimum_cost - 3 - 6 + 8 + 7 + expected = [ + (1, 3, 5), + (1, 2, 1), + (2, 5, 1), + (3, 5, 4), + (3, 4, 5) + ] + for edge in movements.edges(): + expected.remove(edge) # will raise error if edge is missing. + assert expected == [] # will raise error if edge wasn't removed. + + +def test_minimum_cost_flow_successive_shortest_path_unlimited_excess_supply(): + costs, inventory = lecture_23_max_flow_problem() + inventory[1] = 1000 + mcf = minimum_cost_flow_using_successive_shortest_path + total_cost, movements = mcf(costs, inventory) + assert isinstance(movements, Graph) + assert total_cost == lec_23_optimum_cost + expected = [ + (1, 3, 6), + (3, 4, 5), + (3, 5, 5) + ] + for edge in movements.edges(): + expected.remove(edge) # will raise error if edge is missing. + assert expected == [] # will raise error if edge wasn't removed. + + +def test_minimum_cost_flow_successive_shortest_path_unlimited_inadequate_supply(): + costs, inventory = lecture_23_max_flow_problem() + inventory[5] = -10 + mcf = minimum_cost_flow_using_successive_shortest_path + total_cost, movements = mcf(costs, inventory) + assert isinstance(movements, Graph) + assert total_cost == 6 * 6 + 10 * 3 + expected = [ + (1, 3, 6), + (3, 5, 10) + ] + for edge in movements.edges(): + expected.remove(edge) # will raise error if edge is missing. + assert expected == [] # will raise error if edge wasn't removed. + + +def test_min_flow_cost_problem_r4er(): + """ example source http://www.iems.northwestern.edu/~4er/ """ + costs = Graph(from_list=[ + (1, 2, 12), + (1, 4, 12), + (2, 4, 10), + (2, 5, 9), + (3, 2, 13), + (3, 5, 7), + (4, 5, 4), + (4, 6, 8), + (4, 7, 6), + (5, 4, 3), + (5, 7, 9), + (5, 8, 13), + (6, 7, 7), + (8, 7, 3) + ]) + inventory = {1: 100, 2: 80, 3: 130, 6: -200, 7: -60, 8: -40} + mcf = minimum_cost_flow_using_successive_shortest_path + total_cost, movements = mcf(costs, inventory) + assert total_cost == 5820, total_cost + diff --git a/graph-theory/source/tests/test_graph.py b/graph-theory/source/tests/test_graph.py new file mode 100644 index 0000000000000000000000000000000000000000..7c13bab7af55425493f20b63fce2e6278a32c0b3 --- /dev/null +++ b/graph-theory/source/tests/test_graph.py @@ -0,0 +1,365 @@ +from examples.graphs import london_underground +from graph import Graph + + +def graph01(): + """ + :return: Graph. + """ + d = {1: {2: 10, 3: 5}, + 2: {4: 1, 3: 2}, + 3: {2: 3, 4: 9, 5: 2}, + 4: {5: 4}, + 5: {1: 7, 4: 6}} + return Graph(from_dict=d) + + +def test_graph01(): + assert isinstance(graph01(), Graph) + + +def graph02(): + """ + [1]+--->[3]+-->[5]+--->[6] [7] (isolated node) + ^ ^ + +------------+ | + | + [2]+--->[4]+----------> + + """ + g = Graph(from_list=[ + (1, 3, 1), + (2, 4, 1), + (2, 5, 1), + (3, 5, 1), + (4, 6, 1), + (5, 6, 1), + ]) + g.add_node(7) + return g + + +def test_graph02(): + assert isinstance(graph02(), Graph) + + +def graph3x3(): + """ + 1 -> 2 -> 3 + | | | + v v v + 4 -> 5 -> 6 + | | | + v v v + 7 -> 8 -> 9 + + :return: + """ + d = {1: {2: 1, 4: 1}, + 2: {3: 1, 5: 1}, + 3: {6: 1}, + 4: {5: 1, 7: 1}, + 5: {6: 1, 8: 1}, + 6: {9: 1}, + 7: {8: 1}, + 8: {9: 1} + } + return Graph(from_dict=d) + + +def test_graph3x3(): + assert isinstance(graph3x3(), Graph) + + +def graph4x4(): + """ + 1 -> 2 -> 3 -> 4 + | | | | + v v v v + 5 -> 6 -> 7 -> 8 + | | | | + v v v v + 9 -> 10-> 11-> 12 + | | | | + v v v v + 13-> 14-> 15-> 16 + """ + edges = [ + (1, 2, 1), (2, 3, 1), (3, 4, 1), (1, 5, 1), + (5, 6, 1), (6, 7, 1), (7, 8, 1), (2, 6, 1), + (3, 7, 1), (4, 8, 1), (5, 9, 1), (9, 10, 1), + (10, 11, 1), (11, 12, 1), (6, 10, 1), (7, 11, 1), + (8, 12, 1), (9, 13, 1), (13, 14, 1), (14, 15, 1), + (15, 16, 1), (10, 14, 1), (11, 15, 1), (12, 16, 1) + ] + g = Graph() + for s, e, d in edges: + g.add_edge(s, e, d, bidirectional=True) + return g + + +def test_graph4x4(): + assert isinstance(graph4x4(), Graph) + + +def graph5x5(): + edges = [ + (1, 2), (2, 3), (3, 4), (4, 5), + (1, 6), (2, 7), (3, 8), (4, 9), (5, 10), + (6, 7), (7, 8), (8, 9), (9, 10), + (6, 11), (7, 12), (8, 13), (9, 14), (10, 15), + (11, 12), (12, 13), (13, 14), (14, 15), + (11, 16), (12, 17), (13, 18), (14, 19), (15, 20), + (16, 17), (17, 18), (18, 19), (19, 20), + (16, 21), (17, 22), (18, 23), (19, 24), (20, 25), + (21, 22), (22, 23), (23, 24), (24, 25) + ] + g = Graph() + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + return g + + +def test_graph5x5(): + assert isinstance(graph5x5(), Graph) + + +def graph03(): + d = {1: {2: 1, 3: 9, 4: 4, 5: 13, 6: 20}, + 2: {1: 7, 3: 7, 4: 2, 5: 11, 6: 18}, + 3: {8: 20, 4: 4, 5: 4, 6: 16, 7: 16}, + 4: {8: 15, 3: 4, 5: 9, 6: 11, 7: 21}, + 5: {8: 11, 6: 2, 7: 17}, + 6: {8: 9, 7: 5}, + 7: {8: 3}, + 8: {7: 5}} + return Graph(from_dict=d) + + +def test_graph03(): + assert isinstance(graph03(), Graph) + + +def graph04(): + d = {1: {2: 1, 3: 9, 4: 4, 5: 11, 6: 17}, + 2: {1: 7, 3: 7, 4: 2, 5: 9, 6: 15}, + 3: {8: 17, 4: 4, 5: 4, 6: 14, 7: 13}, + 4: {8: 12, 3: 4, 5: 9, 6: 9, 7: 18}, + 5: {8: 9, 6: 2, 7: 15}, + 6: {8: 9, 7: 5}, + 7: {8: 3}, + 8: {7: 5}} + return Graph(from_dict=d) + + +def test_graph04(): + assert isinstance(graph04(), Graph) + + +def graph05(): + """ + 0 ---- 1 ---- 5 + + +---- 6 ---- 7 + + + | + + +---- 8 + + + +- 2 ---- 3 ---- 9 + + + | + 4 +---10 + """ + links = [ + (0, 1, 1), + (0, 2, 1), + (1, 5, 1), + (1, 6, 1), + (2, 3, 1), + (2, 4, 1), + (3, 9, 1), + (3, 10, 1), + (9, 10, 1), + (6, 7, 1), + (6, 8, 1), + (7, 8, 1), + (0, 1, 1), + (0, 1, 1), + (0, 1, 1), + ] + return Graph(from_list=links) + + +def test_graph05(): + assert isinstance(graph05(), Graph) + + +def graph_cycle_5(): + """ cycle of 5 nodes """ + links = [ + (1, 2, 1), + (2, 3, 1), + (3, 4, 1), + (4, 5, 1), + (5, 1, 1), + ] + links.extend([(n2, n1, d) for n1, n2, d in links]) + return Graph(from_list=links) + + +def test_graph_cycle_5(): + graph_cycle_5() + + +def graph_cycle_6(): + """ + cycle of 6 nodes + """ + links = [ + (1, 2, 1), + (2, 3, 1), + (3, 4, 1), + (4, 5, 1), + (5, 6, 1), + (6, 1, 1), + ] + links.extend([(n2, n1, d) for n1, n2, d in links]) + return Graph(from_list=links) + + +def graph_cycle_6(): + """ + cycle of 6 nodes + """ + links = [ + (1, 2, 1), + (2, 3, 1), + (3, 4, 1), + (4, 5, 1), + (5, 6, 1), + (6, 1, 1), + ] + links.extend([(n2, n1, d) for n1, n2, d in links]) + return Graph(from_list=links) + + + +def fully_connected_4(): + """ + fully connected graph with 4 nodes. + """ + L = [ + (0, 3, 1), (0, 2, 1), (0, 1, 1), (3, 2, 1), (3, 1, 1), (3, 0, 1), + (2, 3, 1), (2, 1, 1), (2, 0, 1), (1, 0, 1), (1, 2, 1), (1, 3, 1), + (0,), (1,), (2,), (3,) + ] + g = Graph(from_list=L) + return g + + +def test_fully_connected_4(): + assert isinstance(fully_connected_4(), Graph) + + +def fully_connected_4_diff_length(): + """ + fully connected graph with 4 nodes where lengths increment. + + This graph is good for TSP because greedy algorithms get it wrong every time, + because they can' include the return distance. + """ + L = [ + (0, 3, 1), (0, 2, 2), (0, 1, 3), (3, 2, 4), (3, 1, 5), (3, 0, 6), + (2, 3, 7), (2, 1, 8), (2, 0, 9), (1, 0, 10), (1, 2, 11), (1, 3, 12), + (0,), (1,), (2,), (3,) + ] + g = Graph(from_list=L) + return g + +def test_fully_connected_4_diff_length(): + assert isinstance(fully_connected_4_diff_length(), Graph) + + +def small_project_for_critical_path_method(): + """ F ----------+-G----+ + | | | + A --+---B-----C--+-D----+---E + | | + H-------------------+ + + https://en.wikipedia.org/wiki/Critical_path_method#/media/File:Activity-on-node-v3.svg + """ + tasks = {'A': 10, 'B': 20, 'C': 5, 'D': 10, 'E': 20, 'F': 15, 'G': 5, 'H': 15} + dependencies = [ + ('A', 'B'), + ('B', 'C'), + ('C', 'D'), + ('D', 'E'), + ('A', 'F'), + ('F', 'G'), + ('G', 'E'), + ('A', 'H'), + ('H', 'E'), + ] + + g = Graph() + for n, d in tasks.items(): + g.add_node(n, obj=d) + for n1, n2 in dependencies: + g.add_edge(n1, n2, 0) + return g + + +def test_small_critical_path(): + assert isinstance(small_project_for_critical_path_method(), Graph) + + +def mountain_river_map(): + """ Detailed mountain river map. Contributed by Harry Darby & Hartmut Mause """ + # fmt:off + L = [(0,), (0, 164, 1), (1,), (1, 235, 1), (2,), (2, 1, 1), (3,), (3, 196, 1), (4,), (4, 3, 1), (5,), (5, 225, 1), (6,), (6, 5, 1), (7,), (7, 5, 1), (8,), (8, 211, 1), (9,), (9, 8, 1), (10,), (10, 144, 1), (11,), (11, 10, 1), (12,), (12, 234, 1), (13,), (13, 12, 1), (14,), (14, 172, 1), (15,), (15, 14, 1), (16,), (16, 14, 1), (17,), (17, 184, 1), (18,), (18, 17, 1), (19,), (19, 226, 1), (20,), (20, 19, 1), (21,), (21, 14, 1), (22,), (22, 222, 1), (23,), (23, 22, 1), (24,), (24, 240, 1), (25,), (25, 24, 1), (26,), (26, 241, 1), (27,), (27, 26, 1), (28,), (28, 71, 1), (29,), (29, 28, 1), (30,), (30, 28, 1), (31,), (31, 198, 1), (32,), (32, 31, 1), (33,), (33, 67, 1), (34,), (34, 33, 1), (35,), (35, 247, 1), (36,), (36, 35, 1), (37,), (37, 194, 1), (38,), (38, 37, 1), (39,), (39, 193, 1), (40,), (40, 39, 1), (41,), (41, 39, 1), (42,), (42, 39, 1), (43,), (43, 230, 1), (44,), (44, 43, 1), (45,), (45, 233, 1), (46,), (46, 45, 1), (47,), (47, 238, 1), (48,), (48, 47, 1), (49,), (49, 47, 1), (50,), (50, 215, 1), (51,), (51, 50, 1), (52,), (52, 166, 1), (53,), (53, 52, 1), (54,), (54, 170, 1), (55,), (55, 54, 1), (56,), (56, 231, 1), (57,), (57, 56, 1), (58,), (58, 56, 1), (59,), (59, 206, 1), (60,), (60, 59, 1), (61,), (61, 188, 1), (62,), (62, 61, 1), (63,), (63, 56, 1), (64,), (64, 229, 1), (65,), (65, 64, 1), (66,), (66, 223, 1), (67,), (67, 40, 1), (68,), (68, 2, 1), (68, 4, 1), (69,), (69, 66, 1), (70,), (70, 74, 1), (71,), (71, 65, 1), (72,), (72, 76, 1), (73,), (73, 66, 1), (74,), (74, 244, 1), (75,), (75, 78, 1), (76,), (76, 221, 1), (77,), (77, 66, 1), (78,), (78, 202, 1), (79,), (79, 85, 1), (80,), (80, 81, 1), (81,), (81, 204, 1), (82,), (82, 86, 1), (83,), (83, 66, 1), (84,), (84, 87, 1), (85,), (85, 220, 1), (86,), (86, 250, 1), (87,), (87, 248, 1), (88,), (88, 89, 1), (89,), (89, 251, 1), (90,), (90, 91, 1), (91,), (91, 186, 1), (92,), (92, 95, 1), (93,), (93, 94, 1), (94,), (94, 175, 1), (95,), (95, 180, 1), (96,), (96, 97, 1), (97,), (97, 209, 1), (98,), (98, 100, 1), (99,), (99, 102, 1), (100,), (100, 227, 1), (101,), (101, 106, 1), (102,), (102, 185, 1), (103,), (103, 107, 1), (104,), (104, 106, 1), (105,), (105, 109, 1), (106,), (106, 181, 1), (107,), (107, 135, 1), (108,), (108, 112, 1), (109,), (109, 224, 1), (110,), (110, 113, 1), (111,), (111, 47, 1), (112,), (112, 236, 1), (113,), (113, 190, 1), (114,), (114, 117, 1), (115,), (115, 116, 1), (116,), (116, 218, 1), (117,), (117, 183, 1), (118,), (118, 117, 1), (119,), (119, 120, 1), (120,), (120, 201, 1), (121,), (121, 122, 1), (122,), (122, 243, 1), (123,), (123, 127, 1), (124,), (124, 125, 1), (125,), (125, 197, 1), (126,), (126, 129, 1), (127,), (127, 217, 1), (128,), (128, 125, 1), (129,), (129, 68, 1), (130,), (130, 132, 1), (131,), (131, 136, 1), (132,), (132, 216, 1), (133,), (133, 117, 1), (134,), (134, 138, 1), (135,), (135, 46, 1), (135, 105, 1), (136,), (136, 173, 1), (137,), (137, 117, 1), (138,), (138, 191, 1), (139,), (139, 117, 1), (140,), (140, 141, 1), (141,), (141, 213, 1), (142,), (142, 141, 1), (143,), (143, 147, 1), (144,), (144, 15, 1), (145,), (145, 152, 1), (146,), (146, 154, 1), (146, 167, 1), (147,), (147, 141, 1), (148,), (148, 155, 1), (149,), (149, 141, 1), (150,), (150, 141, 1), (151,), (151, 141, 1), (152,), (152, 242, 1), (153,), (153, 157, 1), (154,), (154, 228, 1), (155,), (155, 195, 1), (156,), (156, 162, 1), (156, 163, 1), (157,), (157, 249, 1), (158,), (158, 159, 1), (159,), (159, 189, 1), (160,), (160, 161, 1), (161,), (161, 228, 1), (162,), (162, 0, 1), (163,), (163, 245, 1), (164,), (164, 165, 1), (165,), (165, 187, 1), (166,), (166, 57, 1), (167,), (167, 200, 1), (168,), (168, 214, 1), (169,), (169, 205, 1), (170,), (170, 60, 1), (170, 62, 1), (171,), (171, 177, 1), (172,), (172, 23, 1), (173,), (173, 137, 1), (174,), (174, 210, 1), (175,), (175, 44, 1), (175, 103, 1), (176,), (176, 118, 1), (177,), (177, 252, 1), (178,), (178, 179, 1), (179,), (179, 239, 1), (180,), (180, 96, 1), (181,), (181, 93, 1), (182,), (183,), (183, 146, 1), (184,), (184, 9, 1), (184, 20, 1), (185,), (185, 104, 1), (186,), (186, 134, 1), (186, 171, 1), (187,), (187, 169, 1), (188,), (188, 63, 1), (189,), (189, 160, 1), (190,), (190, 115, 1), (191,), (191, 139, 1), (192,), (193,), (193, 70, 1), (194,), (194, 42, 1), (195,), (195, 121, 1), (195, 123, 1), (196,), (196, 7, 1), (197,), (197, 126, 1), (198,), (198, 36, 1), (198, 38, 1), (199,), (199, 151, 1), (200,), (201,), (201, 148, 1), (202,), (202, 79, 1), (202, 82, 1), (203,), (203, 149, 1), (204,), (204, 83, 1), (205,), (205, 245, 1), (206,), (206, 58, 1), (207,), (207, 246, 1), (208,), (208, 207, 1), (209,), (209, 98, 1), (209, 99, 1), (210,), (210, 200, 1), (211,), (211, 11, 1), (211, 13, 1), (212,), (212, 142, 1), (213,), (213, 145, 1), (214,), (214, 176, 1), (215,), (215, 72, 1), (215, 75, 1), (216,), (216, 133, 1), (217,), (217, 128, 1), (218,), (218, 88, 1), (218, 168, 1), (219,), (219, 140, 1), (220,), (220, 77, 1), (221,), (221, 69, 1), (222,), (222, 25, 1), (222, 27, 1), (223,), (223, 92, 1), (224,), (224, 111, 1), (225,), (225, 18, 1), (226,), (226, 21, 1), (227,), (227, 101, 1), (228,), (228, 156, 1), (229,), (229, 32, 1), (229, 34, 1), (230,), (230, 48, 1), (231,), (231, 51, 1), (232,), (232, 119, 1), (233,), (233, 49, 1), (234,), (234, 16, 1), (235,), (235, 6, 1), (236,), (236, 90, 1), (236, 110, 1), (237,), (237, 150, 1), (238,), (238, 108, 1), (239,), (239, 130, 1), (239, 131, 1), (240,), (240, 29, 1), (241,), (241, 30, 1), (242,), (242, 153, 1), (243,), (243, 124, 1), (244,), (244, 53, 1), (244, 55, 1), (245,), (245, 208, 1), (246,), (246, 174, 1), (247,), (247, 41, 1), (248,), (248, 73, 1), (249,), (249, 158, 1), (250,), (250, 80, 1), (250, 84, 1), (251,), (251, 114, 1), (252,), (252, 178, 1)] + # fmt:on + g = Graph(from_list=L) + return g + + +def test_mountain_river_map(): + assert isinstance(mountain_river_map(), Graph) + + +def test_london_underground(): + assert isinstance(london_underground(), Graph) + + +def munich_firebrigade_centre(): + """ Contributed by Ross Blandford""" + # fmt:off + g = Graph(from_list= + [[997, 1038, 1], [1038, 1039, 1], [165, 561, 1], [165, 142, 1], [165, 346, 1], [561, 562, 1], [142, 143, 1], [1043, 962, 1], [1043, 968, 1], [1043, 960, 1], [1043, 956, 1], [1043, 964, 1], [1043, 970, 1], [1043, 966, 1], [1043, 954, 1], [1043, 958, 1], [1043, 952, 1], [962, 963, 1], [1041, 946, 1], [1041, 932, 1], [1041, 948, 1], [1041, 942, 1], [1041, 940, 1], [1041, 950, 1], [1041, 934, 1], [1041, 938, 1], [1041, 944, 1], [1041, 936, 1], [946, 947, 1], [9464, 1026, 1], [9464, 4684, 1], [9464, 4685, 1], [9464, 4686, 1], [9464, 4687, 1], [9464, 4688, 1], [9464, 4689, 1], [9464, 4690, 1], [9464, 4691, 1], [9464, 4692, 1], [9464, 4693, 1], [9464, 4694, 1], [9464, 4695, 1], [9464, 4696, 1], [9464, 4697, 1], [9464, 4698, 1], [9464, 4699, 1], [9464, 4700, 1], [9464, 4701, 1], [9464, 4702, 1], [9464, 4703, 1], [9464, 4704, 1], [9464, 4705, 1], [9464, 4706, 1], [9464, 4707, 1], [9464, 4708, 1], [9464, 4709, 1], [9464, 4710, 1], [9464, 4711, 1], [9464, 4712, 1], [9464, 4713, 1], [9464, 4714, 1], [9464, 4715, 1], [9464, 4716, 1], [9464, 4717, 1], [9464, 4718, 1], [9464, 4719, 1], [9464, 4720, 1], [9464, 4721, 1], [9464, 4722, 1], [9464, 4723, 1], [9464, 4724, 1], [9464, 4725, 1], [9464, 4726, 1], [9464, 4727, 1], [9464, 4728, 1], [9464, 4729, 1], [9464, 4730, 1], [9464, 4731, 1], [9464, 4732, 1], [9464, 4733, 1], [9464, 4734, 1], [9464, 4735, 1], [9464, 4736, 1], [9464, 4737, 1], [9464, 4738, 1], [9464, 4739, 1], [9464, 4740, 1], [9464, 4741, 1], [9464, 4742, 1], [9464, 4743, 1], [9464, 4744, 1], [9464, 4745, 1], [9464, 4746, 1], [9464, 4747, 1], [9464, 4748, 1], [9464, 4749, 1], [9464, 4750, 1], [9464, 4751, 1], [9464, 4752, 1], [9464, 4753, 1], [9464, 4754, 1], [9464, 4755, 1], [9464, 4756, 1], [9464, 4757, 1], [9464, 4758, 1], [9464, 4759, 1], [9464, 4760, 1], [9464, 4761, 1], [9464, 4762, 1], [9464, 4763, 1], [9464, 4764, 1], [9464, 4765, 1], [9464, 4766, 1], [9464, 4767, 1], [9464, 4768, 1], [9464, 4769, 1], [9464, 4770, 1], [9464, 4771, 1], [9464, 4772, 1], [9464, 4773, 1], [9464, 4774, 1], [9464, 4775, 1], [9464, 4776, 1], [9464, 4777, 1], [9464, 4778, 1], [9464, 4779, 1], [9464, 4780, 1], [9464, 4781, 1], [9464, 4782, 1], [9464, 4783, 1], [9464, 4784, 1], [9464, 4785, 1], [9464, 4786, 1], [9464, 4787, 1], [9464, 4788, 1], [9464, 4789, 1], [9464, 4790, 1], [9464, 4791, 1], [9464, 4792, 1], [9464, 4793, 1], [9464, 4794, 1], [9464, 4795, 1], [9464, 4796, 1], [9464, 4797, 1], [9464, 4798, 1], [9464, 4799, 1], [9464, 4800, 1], [9464, 4801, 1], [9464, 4802, 1], [9464, 4803, 1], [9464, 4804, 1], [9464, 4805, 1], [9464, 4806, 1], [9464, 4807, 1], [9464, 4808, 1], [9464, 4809, 1], [9464, 4810, 1], [9464, 4811, 1], [9464, 4812, 1], [9464, 4813, 1], [9464, 4814, 1], [9464, 4815, 1], [9464, 4816, 1], [9464, 4817, 1], [9464, 4818, 1], [9464, 4819, 1], [9464, 4820, 1], [9464, 4821, 1], [9464, 4822, 1], [9464, 4823, 1], [9464, 4824, 1], [9464, 4825, 1], [9464, 4826, 1], [9464, 4827, 1], [9464, 4828, 1], [9464, 4829, 1], [9464, 4830, 1], [9464, 4831, 1], [9464, 4832, 1], [9464, 4833, 1], [9464, 4834, 1], [9464, 4835, 1], [9464, 4836, 1], [9464, 4837, 1], [9464, 4838, 1], [9464, 4839, 1], [9464, 4840, 1], [9464, 4841, 1], [9464, 4842, 1], [9464, 4843, 1], [9464, 4844, 1], [9464, 4845, 1], [9464, 4846, 1], [9464, 4847, 1], [9464, 4848, 1], [9464, 4849, 1], [9464, 4850, 1], [9464, 4851, 1], [9464, 4852, 1], [9464, 4853, 1], [9464, 4854, 1], [9464, 4855, 1], [9464, 4856, 1], [9464, 4857, 1], [9464, 4858, 1], [9464, 4859, 1], [9464, 4860, 1], [9464, 4861, 1], [9464, 4862, 1], [9464, 4863, 1], [9464, 4864, 1], [9464, 4865, 1], [9464, 4866, 1], [9464, 4867, 1], [9464, 4868, 1], [9464, 4869, 1], [9464, 4870, 1], [9464, 4871, 1], [9464, 4872, 1], [9464, 4873, 1], [9464, 4874, 1], [9464, 4875, 1], [9464, 4876, 1], [9464, 4877, 1], [9464, 4878, 1], [9464, 4879, 1], [9464, 4880, 1], [9464, 4881, 1], [9464, 4882, 1], [9464, 4883, 1], [9464, 4884, 1], [9464, 4885, 1], [9464, 4886, 1], [9464, 4887, 1], [9464, 4888, 1], [9464, 4889, 1], [9464, 4890, 1], [9464, 4891, 1], [9464, 4892, 1], [9464, 4893, 1], [9464, 4894, 1], [9464, 4895, 1], [9464, 4896, 1], [9464, 4897, 1], [9464, 4898, 1], [9464, 4899, 1], [9464, 4900, 1], [9464, 4901, 1], [9464, 4902, 1], [9464, 4903, 1], [9464, 4904, 1], [9464, 4905, 1], [9464, 4906, 1], [9464, 4907, 1], [9464, 4908, 1], [9464, 4909, 1], [9464, 4910, 1], [9464, 4911, 1], [9464, 4912, 1], [9464, 4913, 1], [9464, 4914, 1], [9464, 4915, 1], [9464, 4916, 1], [9464, 4917, 1], [9464, 4918, 1], [9464, 4919, 1], [9464, 4920, 1], [9464, 4921, 1], [9464, 4922, 1], [9464, 4923, 1], [9464, 4924, 1], [9464, 4925, 1], [9464, 4926, 1], [9464, 4927, 1], [9464, 4928, 1], [9464, 4929, 1], [9464, 4930, 1], [9464, 4931, 1], [9464, 4932, 1], [9464, 4933, 1], [9464, 4934, 1], [9464, 4935, 1], [9464, 4936, 1], [9464, 4937, 1], [9464, 4938, 1], [9464, 4939, 1], [9464, 4940, 1], [9464, 4941, 1], [9464, 4942, 1], [9464, 4943, 1], [9464, 4944, 1], [9464, 4945, 1], [9464, 4946, 1], [9464, 4947, 1], [9464, 4948, 1], [9464, 4949, 1], [9464, 4950, 1], [9464, 4951, 1], [9464, 4952, 1], [9464, 4953, 1], [9464, 4954, 1], [9464, 4955, 1], [9464, 4956, 1], [9464, 4957, 1], [9464, 4958, 1], [9464, 4959, 1], [9464, 4960, 1], [9464, 4961, 1], [9464, 4962, 1], [9464, 4963, 1], [1026, 1027, 1], [963, 9446, 1], [9446, 1002, 1], [9446, 2024, 1], [9446, 2025, 1], [9446, 2026, 1], [9446, 2027, 1], [9446, 2028, 1], [9446, 2029, 1], [9446, 2030, 1], [9446, 2031, 1], [9446, 2032, 1], [9446, 2033, 1], [9446, 2034, 1], [9446, 2035, 1], [9446, 2036, 1], [9446, 2037, 1], [9446, 2038, 1], [9446, 2039, 1], [9446, 2040, 1], [9446, 2041, 1], [9446, 2042, 1], [9446, 2043, 1], [9446, 2044, 1], [9446, 2045, 1], [9446, 2046, 1], [9446, 2047, 1], [9446, 2048, 1], [9446, 2049, 1], [9446, 2050, 1], [9446, 2051, 1], [9446, 2052, 1], [9446, 2053, 1], [9446, 2054, 1], [9446, 2055, 1], [9446, 2056, 1], [9446, 2057, 1], [9446, 2058, 1], [9446, 2059, 1], [9446, 2060, 1], [9446, 2061, 1], [9446, 2062, 1], [9446, 2063, 1], [9446, 2064, 1], [9446, 2065, 1], [9446, 2066, 1], [9446, 2067, 1], [9446, 2068, 1], [9446, 2069, 1], [9446, 2070, 1], [9446, 2071, 1], [9446, 2072, 1], [9446, 2073, 1], [9446, 2074, 1], [9446, 2075, 1], [9446, 2076, 1], [9446, 2077, 1], [9446, 2078, 1], [9446, 2079, 1], [9446, 2080, 1], [9446, 2081, 1], [9446, 2082, 1], [9446, 2083, 1], [9446, 2084, 1], [9446, 2085, 1], [9446, 2086, 1], [9446, 2087, 1], [9446, 2088, 1], [9446, 2089, 1], [9446, 2090, 1], [9446, 2091, 1], [9446, 2092, 1], [9446, 2093, 1], [9446, 2094, 1], [9446, 2095, 1], [9446, 2096, 1], [9446, 2097, 1], [9446, 2098, 1], [9446, 2099, 1], [9446, 2100, 1], [9446, 2101, 1], [9446, 2102, 1], [9446, 2103, 1], [9446, 2104, 1], [9446, 2105, 1], [9446, 2106, 1], [9446, 2107, 1], [9446, 2108, 1], [9446, 2109, 1], [9446, 2110, 1], [9446, 2111, 1], [9446, 2112, 1], [9446, 2113, 1], [9446, 2114, 1], [9446, 2115, 1], [9446, 2116, 1], [9446, 2117, 1], [9446, 2118, 1], [9446, 2119, 1], [9446, 2120, 1], [9446, 2121, 1], [9446, 2122, 1], [9446, 2123, 1], [9446, 2124, 1], [9446, 2125, 1], [9446, 2126, 1], [9446, 2127, 1], [9446, 2128, 1], [9446, 2129, 1], [9446, 2130, 1], [9446, 2131, 1], [9446, 2132, 1], [9446, 2133, 1], [9446, 2134, 1], [9446, 2135, 1], [9446, 2136, 1], [9446, 2137, 1], [9446, 2138, 1], [9446, 2139, 1], [9446, 2140, 1], [9446, 2141, 1], [9446, 2142, 1], [9446, 2143, 1], [9446, 2144, 1], [9446, 2145, 1], [9446, 2146, 1], [9446, 2147, 1], [9446, 2148, 1], [9446, 2149, 1], [9446, 2150, 1], [9446, 2151, 1], [9446, 2152, 1], [9446, 2153, 1], [9446, 2154, 1], [9446, 2155, 1], [9446, 2156, 1], [9446, 2157, 1], [9446, 2158, 1], [9446, 2159, 1], [9446, 2160, 1], [9446, 2161, 1], [9446, 2162, 1], [9446, 2163, 1], [9446, 2444, 1], [9446, 2445, 1], [9446, 2446, 1], [9446, 2447, 1], [9446, 2448, 1], [9446, 2449, 1], [9446, 2450, 1], [9446, 2451, 1], [9446, 2452, 1], [9446, 2453, 1], [9446, 2454, 1], [9446, 2455, 1], [9446, 2456, 1], [9446, 2457, 1], [9446, 2458, 1], [9446, 2459, 1], [9446, 2460, 1], [9446, 2461, 1], [9446, 2462, 1], [9446, 2463, 1], [9446, 2464, 1], [9446, 2465, 1], [9446, 2466, 1], [9446, 2467, 1], [9446, 2468, 1], [9446, 2469, 1], [9446, 2470, 1], [9446, 2471, 1], [9446, 2472, 1], [9446, 2473, 1], [9446, 2474, 1], [9446, 2475, 1], [9446, 2476, 1], [9446, 2477, 1], [9446, 2478, 1], [9446, 2479, 1], [9446, 2480, 1], [9446, 2481, 1], [9446, 2482, 1], [9446, 2483, 1], [9446, 2484, 1], [9446, 2485, 1], [9446, 2486, 1], [9446, 2487, 1], [9446, 2488, 1], [9446, 2489, 1], [9446, 2490, 1], [9446, 2491, 1], [9446, 2492, 1], [9446, 2493, 1], [9446, 2494, 1], [9446, 2495, 1], [9446, 2496, 1], [9446, 2497, 1], [9446, 2498, 1], [9446, 2499, 1], [9446, 2500, 1], [9446, 2501, 1], [9446, 2502, 1], [9446, 2503, 1], [9446, 2504, 1], [9446, 2505, 1], [9446, 2506, 1], [9446, 2507, 1], [9446, 2508, 1], [9446, 2509, 1], [9446, 2510, 1], [9446, 2511, 1], [9446, 2512, 1], [9446, 2513, 1], [9446, 2514, 1], [9446, 2515, 1], [9446, 2516, 1], [9446, 2517, 1], [9446, 2518, 1], [9446, 2519, 1], [9446, 2520, 1], [9446, 2521, 1], [9446, 2522, 1], [9446, 2523, 1], [9446, 2524, 1], [9446, 2525, 1], [9446, 2526, 1], [9446, 2527, 1], [9446, 2528, 1], [9446, 2529, 1], [9446, 2530, 1], [9446, 2531, 1], [9446, 2532, 1], [9446, 2533, 1], [9446, 2534, 1], [9446, 2535, 1], [9446, 2536, 1], [9446, 2537, 1], [9446, 2538, 1], [9446, 2539, 1], [9446, 2540, 1], [9446, 2541, 1], [9446, 2542, 1], [9446, 2543, 1], [9446, 2544, 1], [9446, 2545, 1], [9446, 2546, 1], [9446, 2547, 1], [9446, 2548, 1], [9446, 2549, 1], [9446, 2550, 1], [9446, 2551, 1], [9446, 2552, 1], [9446, 2553, 1], [9446, 2554, 1], [9446, 2555, 1], [9446, 2556, 1], [9446, 2557, 1], [9446, 2558, 1], [9446, 2559, 1], [9446, 2560, 1], [9446, 2561, 1], [9446, 2562, 1], [9446, 2563, 1], [9446, 2564, 1], [9446, 2565, 1], [9446, 2566, 1], [9446, 2567, 1], [9446, 2568, 1], [9446, 2569, 1], [9446, 2570, 1], [9446, 2571, 1], [9446, 2572, 1], [9446, 2573, 1], [9446, 2574, 1], [9446, 2575, 1], [9446, 2576, 1], [9446, 2577, 1], [9446, 2578, 1], [9446, 2579, 1], [9446, 2580, 1], [9446, 2581, 1], [9446, 2582, 1], [9446, 2583, 1], [9454, 930, 1], [9454, 8604, 1], [9454, 8605, 1], [9454, 8606, 1], [9454, 8607, 1], [9454, 8608, 1], [9454, 8609, 1], [9454, 8610, 1], [9454, 8611, 1], [9454, 8612, 1], [9454, 8613, 1], [9454, 8614, 1], [9454, 8615, 1], [9454, 8616, 1], [9454, 8617, 1], [9454, 8618, 1], [9454, 8619, 1], [9454, 8620, 1], [9454, 8621, 1], [9454, 8622, 1], [9454, 8623, 1], [9454, 8624, 1], [9454, 8625, 1], [9454, 8626, 1], [9454, 8627, 1], [9454, 8628, 1], [9454, 8629, 1], [9454, 8630, 1], [9454, 8631, 1], [9454, 8632, 1], [9454, 8633, 1], [9454, 8634, 1], [9454, 8635, 1], [9454, 8636, 1], [9454, 8637, 1], [9454, 8638, 1], [9454, 8639, 1], [9454, 8640, 1], [9454, 8641, 1], [9454, 8642, 1], [9454, 8643, 1], [9454, 8644, 1], [9454, 8645, 1], [9454, 8646, 1], [9454, 8647, 1], [9454, 8648, 1], [9454, 8649, 1], [9454, 8650, 1], [9454, 8651, 1], [9454, 8652, 1], [9454, 8653, 1], [9454, 8654, 1], [9454, 8655, 1], [9454, 8656, 1], [9454, 8657, 1], [9454, 8658, 1], [9454, 8659, 1], [9454, 8660, 1], [9454, 8661, 1], [9454, 8662, 1], [9454, 8663, 1], [9454, 8664, 1], [9454, 8665, 1], [9454, 8666, 1], [9454, 8667, 1], [9454, 8668, 1], [9454, 8669, 1], [9454, 8670, 1], [9454, 8671, 1], [9454, 8672, 1], [9454, 8673, 1], [9454, 8674, 1], [9454, 8675, 1], [9454, 8676, 1], [9454, 8677, 1], [9454, 8678, 1], [9454, 8679, 1], [9454, 8680, 1], [9454, 8681, 1], [9454, 8682, 1], [9454, 8683, 1], [9454, 8684, 1], [9454, 8685, 1], [9454, 8686, 1], [9454, 8687, 1], [9454, 8688, 1], [9454, 8689, 1], [9454, 8690, 1], [9454, 8691, 1], [9454, 8692, 1], [9454, 8693, 1], [9454, 8694, 1], [9454, 8695, 1], [9454, 8696, 1], [9454, 8697, 1], [9454, 8698, 1], [9454, 8699, 1], [9454, 8700, 1], [9454, 8701, 1], [9454, 8702, 1], [9454, 8703, 1], [9454, 8704, 1], [9454, 8705, 1], [9454, 8706, 1], [9454, 8707, 1], [9454, 8708, 1], [9454, 8709, 1], [9454, 8710, 1], [9454, 8711, 1], [9454, 8712, 1], [9454, 8713, 1], [9454, 8714, 1], [9454, 8715, 1], [9454, 8716, 1], [9454, 8717, 1], [9454, 8718, 1], [9454, 8719, 1], [9454, 8720, 1], [9454, 8721, 1], [9454, 8722, 1], [9454, 8723, 1], [9454, 8724, 1], [9454, 8725, 1], [9454, 8726, 1], [9454, 8727, 1], [9454, 8728, 1], [9454, 8729, 1], [9454, 8730, 1], [9454, 8731, 1], [9454, 8732, 1], [9454, 8733, 1], [9454, 8734, 1], [9454, 8735, 1], [9454, 8736, 1], [9454, 8737, 1], [9454, 8738, 1], [9454, 8739, 1], [9454, 8740, 1], [9454, 8741, 1], [9454, 8742, 1], [9454, 8743, 1], [9454, 9304, 1], [9454, 9305, 1], [9454, 9306, 1], [9454, 9307, 1], [9454, 9308, 1], [9454, 9309, 1], [9454, 9310, 1], [9454, 9311, 1], [9454, 9312, 1], [9454, 9313, 1], [9454, 9314, 1], [9454, 9315, 1], [9454, 9316, 1], [9454, 9317, 1], [9454, 9318, 1], [9454, 9319, 1], [9454, 9320, 1], [9454, 9321, 1], [9454, 9322, 1], [9454, 9323, 1], [9454, 9324, 1], [9454, 9325, 1], [9454, 9326, 1], [9454, 9327, 1], [9454, 9328, 1], [9454, 9329, 1], [9454, 9330, 1], [9454, 9331, 1], [9454, 9332, 1], [9454, 9333, 1], [9454, 9334, 1], [9454, 9335, 1], [9454, 9336, 1], [9454, 9337, 1], [9454, 9338, 1], [9454, 9339, 1], [9454, 9340, 1], [9454, 9341, 1], [9454, 9342, 1], [9454, 9343, 1], [9454, 9344, 1], [9454, 9345, 1], [9454, 9346, 1], [9454, 9347, 1], [9454, 9348, 1], [9454, 9349, 1], [9454, 9350, 1], [9454, 9351, 1], [9454, 9352, 1], [9454, 9353, 1], [9454, 9354, 1], [9454, 9355, 1], [9454, 9356, 1], [9454, 9357, 1], [9454, 9358, 1], [9454, 9359, 1], [9454, 9360, 1], [9454, 9361, 1], [9454, 9362, 1], [9454, 9363, 1], [9454, 9364, 1], [9454, 9365, 1], [9454, 9366, 1], [9454, 9367, 1], [9454, 9368, 1], [9454, 9369, 1], [9454, 9370, 1], [9454, 9371, 1], [9454, 9372, 1], [9454, 9373, 1], [9454, 9374, 1], [9454, 9375, 1], [9454, 9376, 1], [9454, 9377, 1], [9454, 9378, 1], [9454, 9379, 1], [9454, 9380, 1], [9454, 9381, 1], [9454, 9382, 1], [9454, 9383, 1], [9454, 9384, 1], [9454, 9385, 1], [9454, 9386, 1], [9454, 9387, 1], [9454, 9388, 1], [9454, 9389, 1], [9454, 9390, 1], [9454, 9391, 1], [9454, 9392, 1], [9454, 9393, 1], [9454, 9394, 1], [9454, 9395, 1], [9454, 9396, 1], [9454, 9397, 1], [9454, 9398, 1], [9454, 9399, 1], [9454, 9400, 1], [9454, 9401, 1], [9454, 9402, 1], [9454, 9403, 1], [9454, 9404, 1], [9454, 9405, 1], [9454, 9406, 1], [9454, 9407, 1], [9454, 9408, 1], [9454, 9409, 1], [9454, 9410, 1], [9454, 9411, 1], [9454, 9412, 1], [9454, 9413, 1], [9454, 9414, 1], [9454, 9415, 1], [9454, 9416, 1], [9454, 9417, 1], [9454, 9418, 1], [9454, 9419, 1], [9454, 9420, 1], [9454, 9421, 1], [9454, 9422, 1], [9454, 9423, 1], [9454, 9424, 1], [9454, 9425, 1], [9454, 9426, 1], [9454, 9427, 1], [9454, 9428, 1], [9454, 9429, 1], [9454, 9430, 1], [9454, 9431, 1], [9454, 9432, 1], [9454, 9433, 1], [9454, 9434, 1], [9454, 9435, 1], [9454, 9436, 1], [9454, 9437, 1], [9454, 9438, 1], [9454, 9439, 1], [9454, 9440, 1], [9454, 9441, 1], [9454, 9442, 1], [9454, 9443, 1], [930, 931, 1], [9449, 1008, 1], [9449, 6224, 1], [9449, 6225, 1], [9449, 6226, 1], [9449, 6227, 1], [9449, 6228, 1], [9449, 6229, 1], [9449, 6230, 1], [9449, 6231, 1], [9449, 6232, 1], [9449, 6233, 1], [9449, 6234, 1], [9449, 6235, 1], [9449, 6236, 1], [9449, 6237, 1], [9449, 6238, 1], [9449, 6239, 1], [9449, 6240, 1], [9449, 6241, 1], [9449, 6242, 1], [9449, 6243, 1], [9449, 6244, 1], [9449, 6245, 1], [9449, 6246, 1], [9449, 6247, 1], [9449, 6248, 1], [9449, 6249, 1], [9449, 6250, 1], [9449, 6251, 1], [9449, 6252, 1], [9449, 6253, 1], [9449, 6254, 1], [9449, 6255, 1], [9449, 6256, 1], [9449, 6257, 1], [9449, 6258, 1], [9449, 6259, 1], [9449, 6260, 1], [9449, 6261, 1], [9449, 6262, 1], [9449, 6263, 1], [9449, 6264, 1], [9449, 6265, 1], [9449, 6266, 1], [9449, 6267, 1], [9449, 6268, 1], [9449, 6269, 1], [9449, 6270, 1], [9449, 6271, 1], [9449, 6272, 1], [9449, 6273, 1], [9449, 6274, 1], [9449, 6275, 1], [9449, 6276, 1], [9449, 6277, 1], [9449, 6278, 1], [9449, 6279, 1], [9449, 6280, 1], [9449, 6281, 1], [9449, 6282, 1], [9449, 6283, 1], [9449, 6284, 1], [9449, 6285, 1], [9449, 6286, 1], [9449, 6287, 1], [9449, 6288, 1], [9449, 6289, 1], [9449, 6290, 1], [9449, 6291, 1], [9449, 6292, 1], [9449, 6293, 1], [9449, 6294, 1], [9449, 6295, 1], [9449, 6296, 1], [9449, 6297, 1], [9449, 6298, 1], [9449, 6299, 1], [9449, 6300, 1], [9449, 6301, 1], [9449, 6302, 1], [9449, 6303, 1], [9449, 6304, 1], [9449, 6305, 1], [9449, 6306, 1], [9449, 6307, 1], [9449, 6308, 1], [9449, 6309, 1], [9449, 6310, 1], [9449, 6311, 1], [9449, 6312, 1], [9449, 6313, 1], [9449, 6314, 1], [9449, 6315, 1], [9449, 6316, 1], [9449, 6317, 1], [9449, 6318, 1], [9449, 6319, 1], [9449, 6320, 1], [9449, 6321, 1], [9449, 6322, 1], [9449, 6323, 1], [9449, 6324, 1], [9449, 6325, 1], [9449, 6326, 1], [9449, 6327, 1], [9449, 6328, 1], [9449, 6329, 1], [9449, 6330, 1], [9449, 6331, 1], [9449, 6332, 1], [9449, 6333, 1], [9449, 6334, 1], [9449, 6335, 1], [9449, 6336, 1], [9449, 6337, 1], [9449, 6338, 1], [9449, 6339, 1], [9449, 6340, 1], [9449, 6341, 1], [9449, 6342, 1], [9449, 6343, 1], [9449, 6344, 1], [9449, 6345, 1], [9449, 6346, 1], [9449, 6347, 1], [9449, 6348, 1], [9449, 6349, 1], [9449, 6350, 1], [9449, 6351, 1], [9449, 6352, 1], [9449, 6353, 1], [9449, 6354, 1], [9449, 6355, 1], [9449, 6356, 1], [9449, 6357, 1], [9449, 6358, 1], [9449, 6359, 1], [9449, 6360, 1], [9449, 6361, 1], [9449, 6362, 1], [9449, 6363, 1], [9449, 6644, 1], [9449, 6645, 1], [9449, 6646, 1], [9449, 6647, 1], [9449, 6648, 1], [9449, 6649, 1], [9449, 6650, 1], [9449, 6651, 1], [9449, 6652, 1], [9449, 6653, 1], [9449, 6654, 1], [9449, 6655, 1], [9449, 6656, 1], [9449, 6657, 1], [9449, 6658, 1], [9449, 6659, 1], [9449, 6660, 1], [9449, 6661, 1], [9449, 6662, 1], [9449, 6663, 1], [9449, 6664, 1], [9449, 6665, 1], [9449, 6666, 1], [9449, 6667, 1], [9449, 6668, 1], [9449, 6669, 1], [9449, 6670, 1], [9449, 6671, 1], [9449, 6672, 1], [9449, 6673, 1], [9449, 6674, 1], [9449, 6675, 1], [9449, 6676, 1], [9449, 6677, 1], [9449, 6678, 1], [9449, 6679, 1], [9449, 6680, 1], [9449, 6681, 1], [9449, 6682, 1], [9449, 6683, 1], [9449, 6684, 1], [9449, 6685, 1], [9449, 6686, 1], [9449, 6687, 1], [9449, 6688, 1], [9449, 6689, 1], [9449, 6690, 1], [9449, 6691, 1], [9449, 6692, 1], [9449, 6693, 1], [9449, 6694, 1], [9449, 6695, 1], [9449, 6696, 1], [9449, 6697, 1], [9449, 6698, 1], [9449, 6699, 1], [9449, 6700, 1], [9449, 6701, 1], [9449, 6702, 1], [9449, 6703, 1], [9449, 6704, 1], [9449, 6705, 1], [9449, 6706, 1], [9449, 6707, 1], [9449, 6708, 1], [9449, 6709, 1], [9449, 6710, 1], [9449, 6711, 1], [9449, 6712, 1], [9449, 6713, 1], [9449, 6714, 1], [9449, 6715, 1], [9449, 6716, 1], [9449, 6717, 1], [9449, 6718, 1], [9449, 6719, 1], [9449, 6720, 1], [9449, 6721, 1], [9449, 6722, 1], [9449, 6723, 1], [9449, 6724, 1], [9449, 6725, 1], [9449, 6726, 1], [9449, 6727, 1], [9449, 6728, 1], [9449, 6729, 1], [9449, 6730, 1], [9449, 6731, 1], [9449, 6732, 1], [9449, 6733, 1], [9449, 6734, 1], [9449, 6735, 1], [9449, 6736, 1], [9449, 6737, 1], [9449, 6738, 1], [9449, 6739, 1], [9449, 6740, 1], [9449, 6741, 1], [9449, 6742, 1], [9449, 6743, 1], [9449, 6744, 1], [9449, 6745, 1], [9449, 6746, 1], [9449, 6747, 1], [9449, 6748, 1], [9449, 6749, 1], [9449, 6750, 1], [9449, 6751, 1], [9449, 6752, 1], [9449, 6753, 1], [9449, 6754, 1], [9449, 6755, 1], [9449, 6756, 1], [9449, 6757, 1], [9449, 6758, 1], [9449, 6759, 1], [9449, 6760, 1], [9449, 6761, 1], [9449, 6762, 1], [9449, 6763, 1], [9449, 6764, 1], [9449, 6765, 1], [9449, 6766, 1], [9449, 6767, 1], [9449, 6768, 1], [9449, 6769, 1], [9449, 6770, 1], [9449, 6771, 1], [9449, 6772, 1], [9449, 6773, 1], [9449, 6774, 1], [9449, 6775, 1], [9449, 6776, 1], [9449, 6777, 1], [9449, 6778, 1], [9449, 6779, 1], [9449, 6780, 1], [9449, 6781, 1], [9449, 6782, 1], [9449, 6783, 1], [1008, 1009, 1], [1001, 1038, 1], [617, 293, 1], [293, 294, 1], [1027, 1036, 1], [1036, 1037, 1], [947, 9465, 1], [9465, 1030, 1], [9465, 3844, 1], [9465, 3845, 1], [9465, 3846, 1], [9465, 3847, 1], [9465, 3848, 1], [9465, 3849, 1], [9465, 3850, 1], [9465, 3851, 1], [9465, 3852, 1], [9465, 3853, 1], [9465, 3854, 1], [9465, 3855, 1], [9465, 3856, 1], [9465, 3857, 1], [9465, 3858, 1], [9465, 3859, 1], [9465, 3860, 1], [9465, 3861, 1], [9465, 3862, 1], [9465, 3863, 1], [9465, 3864, 1], [9465, 3865, 1], [9465, 3866, 1], [9465, 3867, 1], [9465, 3868, 1], [9465, 3869, 1], [9465, 3870, 1], [9465, 3871, 1], [9465, 3872, 1], [9465, 3873, 1], [9465, 3874, 1], [9465, 3875, 1], [9465, 3876, 1], [9465, 3877, 1], [9465, 3878, 1], [9465, 3879, 1], [9465, 3880, 1], [9465, 3881, 1], [9465, 3882, 1], [9465, 3883, 1], [9465, 3884, 1], [9465, 3885, 1], [9465, 3886, 1], [9465, 3887, 1], [9465, 3888, 1], [9465, 3889, 1], [9465, 3890, 1], [9465, 3891, 1], [9465, 3892, 1], [9465, 3893, 1], [9465, 3894, 1], [9465, 3895, 1], [9465, 3896, 1], [9465, 3897, 1], [9465, 3898, 1], [9465, 3899, 1], [9465, 3900, 1], [9465, 3901, 1], [9465, 3902, 1], [9465, 3903, 1], [9465, 3904, 1], [9465, 3905, 1], [9465, 3906, 1], [9465, 3907, 1], [9465, 3908, 1], [9465, 3909, 1], [9465, 3910, 1], [9465, 3911, 1], [9465, 3912, 1], [9465, 3913, 1], [9465, 3914, 1], [9465, 3915, 1], [9465, 3916, 1], [9465, 3917, 1], [9465, 3918, 1], [9465, 3919, 1], [9465, 3920, 1], [9465, 3921, 1], [9465, 3922, 1], [9465, 3923, 1], [9465, 3924, 1], [9465, 3925, 1], [9465, 3926, 1], [9465, 3927, 1], [9465, 3928, 1], [9465, 3929, 1], [9465, 3930, 1], [9465, 3931, 1], [9465, 3932, 1], [9465, 3933, 1], [9465, 3934, 1], [9465, 3935, 1], [9465, 3936, 1], [9465, 3937, 1], [9465, 3938, 1], [9465, 3939, 1], [9465, 3940, 1], [9465, 3941, 1], [9465, 3942, 1], [9465, 3943, 1], [9465, 3944, 1], [9465, 3945, 1], [9465, 3946, 1], [9465, 3947, 1], [9465, 3948, 1], [9465, 3949, 1], [9465, 3950, 1], [9465, 3951, 1], [9465, 3952, 1], [9465, 3953, 1], [9465, 3954, 1], [9465, 3955, 1], [9465, 3956, 1], [9465, 3957, 1], [9465, 3958, 1], [9465, 3959, 1], [9465, 3960, 1], [9465, 3961, 1], [9465, 3962, 1], [9465, 3963, 1], [9465, 3964, 1], [9465, 3965, 1], [9465, 3966, 1], [9465, 3967, 1], [9465, 3968, 1], [9465, 3969, 1], [9465, 3970, 1], [9465, 3971, 1], [9465, 3972, 1], [9465, 3973, 1], [9465, 3974, 1], [9465, 3975, 1], [9465, 3976, 1], [9465, 3977, 1], [9465, 3978, 1], [9465, 3979, 1], [9465, 3980, 1], [9465, 3981, 1], [9465, 3982, 1], [9465, 3983, 1], [9465, 3984, 1], [9465, 3985, 1], [9465, 3986, 1], [9465, 3987, 1], [9465, 3988, 1], [9465, 3989, 1], [9465, 3990, 1], [9465, 3991, 1], [9465, 3992, 1], [9465, 3993, 1], [9465, 3994, 1], [9465, 3995, 1], [9465, 3996, 1], [9465, 3997, 1], [9465, 3998, 1], [9465, 3999, 1], [9465, 4000, 1], [9465, 4001, 1], [9465, 4002, 1], [9465, 4003, 1], [9465, 4004, 1], [9465, 4005, 1], [9465, 4006, 1], [9465, 4007, 1], [9465, 4008, 1], [9465, 4009, 1], [9465, 4010, 1], [9465, 4011, 1], [9465, 4012, 1], [9465, 4013, 1], [9465, 4014, 1], [9465, 4015, 1], [9465, 4016, 1], [9465, 4017, 1], [9465, 4018, 1], [9465, 4019, 1], [9465, 4020, 1], [9465, 4021, 1], [9465, 4022, 1], [9465, 4023, 1], [9465, 4024, 1], [9465, 4025, 1], [9465, 4026, 1], [9465, 4027, 1], [9465, 4028, 1], [9465, 4029, 1], [9465, 4030, 1], [9465, 4031, 1], [9465, 4032, 1], [9465, 4033, 1], [9465, 4034, 1], [9465, 4035, 1], [9465, 4036, 1], [9465, 4037, 1], [9465, 4038, 1], [9465, 4039, 1], [9465, 4040, 1], [9465, 4041, 1], [9465, 4042, 1], [9465, 4043, 1], [9465, 4044, 1], [9465, 4045, 1], [9465, 4046, 1], [9465, 4047, 1], [9465, 4048, 1], [9465, 4049, 1], [9465, 4050, 1], [9465, 4051, 1], [9465, 4052, 1], [9465, 4053, 1], [9465, 4054, 1], [9465, 4055, 1], [9465, 4056, 1], [9465, 4057, 1], [9465, 4058, 1], [9465, 4059, 1], [9465, 4060, 1], [9465, 4061, 1], [9465, 4062, 1], [9465, 4063, 1], [9465, 4064, 1], [9465, 4065, 1], [9465, 4066, 1], [9465, 4067, 1], [9465, 4068, 1], [9465, 4069, 1], [9465, 4070, 1], [9465, 4071, 1], [9465, 4072, 1], [9465, 4073, 1], [9465, 4074, 1], [9465, 4075, 1], [9465, 4076, 1], [9465, 4077, 1], [9465, 4078, 1], [9465, 4079, 1], [9465, 4080, 1], [9465, 4081, 1], [9465, 4082, 1], [9465, 4083, 1], [9465, 4084, 1], [9465, 4085, 1], [9465, 4086, 1], [9465, 4087, 1], [9465, 4088, 1], [9465, 4089, 1], [9465, 4090, 1], [9465, 4091, 1], [9465, 4092, 1], [9465, 4093, 1], [9465, 4094, 1], [9465, 4095, 1], [9465, 4096, 1], [9465, 4097, 1], [9465, 4098, 1], [9465, 4099, 1], [9465, 4100, 1], [9465, 4101, 1], [9465, 4102, 1], [9465, 4103, 1], [9465, 4104, 1], [9465, 4105, 1], [9465, 4106, 1], [9465, 4107, 1], [9465, 4108, 1], [9465, 4109, 1], [9465, 4110, 1], [9465, 4111, 1], [9465, 4112, 1], [9465, 4113, 1], [9465, 4114, 1], [9465, 4115, 1], [9465, 4116, 1], [9465, 4117, 1], [9465, 4118, 1], [9465, 4119, 1], [9465, 4120, 1], [9465, 4121, 1], [9465, 4122, 1], [9465, 4123, 1], [226, 896, 1], [896, 897, 1], [892, 550, 1], [892, 513, 1], [892, 314, 1], [550, 551, 1], [406, 290, 1], [290, 494, 1], [921, 1034, 1], [1034, 1035, 1], [610, 236, 1], [610, 864, 1], [236, 278, 1], [292, 403, 1], [403, 404, 1], [1009, 1038, 1], [979, 9461, 1], [9461, 916, 1], [9461, 2724, 1], [9461, 2725, 1], [9461, 2726, 1], [9461, 2727, 1], [9461, 2728, 1], [9461, 2729, 1], [9461, 2730, 1], [9461, 2731, 1], [9461, 2732, 1], [9461, 2733, 1], [9461, 2734, 1], [9461, 2735, 1], [9461, 2736, 1], [9461, 2737, 1], [9461, 2738, 1], [9461, 2739, 1], [9461, 2740, 1], [9461, 2741, 1], [9461, 2742, 1], [9461, 2743, 1], [9461, 2744, 1], [9461, 2745, 1], [9461, 2746, 1], [9461, 2747, 1], [9461, 2748, 1], [9461, 2749, 1], [9461, 2750, 1], [9461, 2751, 1], [9461, 2752, 1], [9461, 2753, 1], [9461, 2754, 1], [9461, 2755, 1], [9461, 2756, 1], [9461, 2757, 1], [9461, 2758, 1], [9461, 2759, 1], [9461, 2760, 1], [9461, 2761, 1], [9461, 2762, 1], [9461, 2763, 1], [9461, 2764, 1], [9461, 2765, 1], [9461, 2766, 1], [9461, 2767, 1], [9461, 2768, 1], [9461, 2769, 1], [9461, 2770, 1], [9461, 2771, 1], [9461, 2772, 1], [9461, 2773, 1], [9461, 2774, 1], [9461, 2775, 1], [9461, 2776, 1], [9461, 2777, 1], [9461, 2778, 1], [9461, 2779, 1], [9461, 2780, 1], [9461, 2781, 1], [9461, 2782, 1], [9461, 2783, 1], [9461, 2784, 1], [9461, 2785, 1], [9461, 2786, 1], [9461, 2787, 1], [9461, 2788, 1], [9461, 2789, 1], [9461, 2790, 1], [9461, 2791, 1], [9461, 2792, 1], [9461, 2793, 1], [9461, 2794, 1], [9461, 2795, 1], [9461, 2796, 1], [9461, 2797, 1], [9461, 2798, 1], [9461, 2799, 1], [9461, 2800, 1], [9461, 2801, 1], [9461, 2802, 1], [9461, 2803, 1], [9461, 2804, 1], [9461, 2805, 1], [9461, 2806, 1], [9461, 2807, 1], [9461, 2808, 1], [9461, 2809, 1], [9461, 2810, 1], [9461, 2811, 1], [9461, 2812, 1], [9461, 2813, 1], [9461, 2814, 1], [9461, 2815, 1], [9461, 2816, 1], [9461, 2817, 1], [9461, 2818, 1], [9461, 2819, 1], [9461, 2820, 1], [9461, 2821, 1], [9461, 2822, 1], [9461, 2823, 1], [9461, 2824, 1], [9461, 2825, 1], [9461, 2826, 1], [9461, 2827, 1], [9461, 2828, 1], [9461, 2829, 1], [9461, 2830, 1], [9461, 2831, 1], [9461, 2832, 1], [9461, 2833, 1], [9461, 2834, 1], [9461, 2835, 1], [9461, 2836, 1], [9461, 2837, 1], [9461, 2838, 1], [9461, 2839, 1], [9461, 2840, 1], [9461, 2841, 1], [9461, 2842, 1], [9461, 2843, 1], [9461, 2844, 1], [9461, 2845, 1], [9461, 2846, 1], [9461, 2847, 1], [9461, 2848, 1], [9461, 2849, 1], [9461, 2850, 1], [9461, 2851, 1], [9461, 2852, 1], [9461, 2853, 1], [9461, 2854, 1], [9461, 2855, 1], [9461, 2856, 1], [9461, 2857, 1], [9461, 2858, 1], [9461, 2859, 1], [9461, 2860, 1], [9461, 2861, 1], [9461, 2862, 1], [9461, 2863, 1], [9461, 3424, 1], [9461, 3425, 1], [9461, 3426, 1], [9461, 3427, 1], [9461, 3428, 1], [9461, 3429, 1], [9461, 3430, 1], [9461, 3431, 1], [9461, 3432, 1], [9461, 3433, 1], [9461, 3434, 1], [9461, 3435, 1], [9461, 3436, 1], [9461, 3437, 1], [9461, 3438, 1], [9461, 3439, 1], [9461, 3440, 1], [9461, 3441, 1], [9461, 3442, 1], [9461, 3443, 1], [9461, 3444, 1], [9461, 3445, 1], [9461, 3446, 1], [9461, 3447, 1], [9461, 3448, 1], [9461, 3449, 1], [9461, 3450, 1], [9461, 3451, 1], [9461, 3452, 1], [9461, 3453, 1], [9461, 3454, 1], [9461, 3455, 1], [9461, 3456, 1], [9461, 3457, 1], [9461, 3458, 1], [9461, 3459, 1], [9461, 3460, 1], [9461, 3461, 1], [9461, 3462, 1], [9461, 3463, 1], [9461, 3464, 1], [9461, 3465, 1], [9461, 3466, 1], [9461, 3467, 1], [9461, 3468, 1], [9461, 3469, 1], [9461, 3470, 1], [9461, 3471, 1], [9461, 3472, 1], [9461, 3473, 1], [9461, 3474, 1], [9461, 3475, 1], [9461, 3476, 1], [9461, 3477, 1], [9461, 3478, 1], [9461, 3479, 1], [9461, 3480, 1], [9461, 3481, 1], [9461, 3482, 1], [9461, 3483, 1], [9461, 3484, 1], [9461, 3485, 1], [9461, 3486, 1], [9461, 3487, 1], [9461, 3488, 1], [9461, 3489, 1], [9461, 3490, 1], [9461, 3491, 1], [9461, 3492, 1], [9461, 3493, 1], [9461, 3494, 1], [9461, 3495, 1], [9461, 3496, 1], [9461, 3497, 1], [9461, 3498, 1], [9461, 3499, 1], [9461, 3500, 1], [9461, 3501, 1], [9461, 3502, 1], [9461, 3503, 1], [9461, 3504, 1], [9461, 3505, 1], [9461, 3506, 1], [9461, 3507, 1], [9461, 3508, 1], [9461, 3509, 1], [9461, 3510, 1], [9461, 3511, 1], [9461, 3512, 1], [9461, 3513, 1], [9461, 3514, 1], [9461, 3515, 1], [9461, 3516, 1], [9461, 3517, 1], [9461, 3518, 1], [9461, 3519, 1], [9461, 3520, 1], [9461, 3521, 1], [9461, 3522, 1], [9461, 3523, 1], [9461, 3524, 1], [9461, 3525, 1], [9461, 3526, 1], [9461, 3527, 1], [9461, 3528, 1], [9461, 3529, 1], [9461, 3530, 1], [9461, 3531, 1], [9461, 3532, 1], [9461, 3533, 1], [9461, 3534, 1], [9461, 3535, 1], [9461, 3536, 1], [9461, 3537, 1], [9461, 3538, 1], [9461, 3539, 1], [9461, 3540, 1], [9461, 3541, 1], [9461, 3542, 1], [9461, 3543, 1], [9461, 3544, 1], [9461, 3545, 1], [9461, 3546, 1], [9461, 3547, 1], [9461, 3548, 1], [9461, 3549, 1], [9461, 3550, 1], [9461, 3551, 1], [9461, 3552, 1], [9461, 3553, 1], [9461, 3554, 1], [9461, 3555, 1], [9461, 3556, 1], [9461, 3557, 1], [9461, 3558, 1], [9461, 3559, 1], [9461, 3560, 1], [9461, 3561, 1], [9461, 3562, 1], [9461, 3563, 1], [935, 9472, 1], [9472, 1012, 1], [9472, 2164, 1], [9472, 2165, 1], [9472, 2166, 1], [9472, 2167, 1], [9472, 2168, 1], [9472, 2169, 1], [9472, 2170, 1], [9472, 2171, 1], [9472, 2172, 1], [9472, 2173, 1], [9472, 2174, 1], [9472, 2175, 1], [9472, 2176, 1], [9472, 2177, 1], [9472, 2178, 1], [9472, 2179, 1], [9472, 2180, 1], [9472, 2181, 1], [9472, 2182, 1], [9472, 2183, 1], [9472, 2184, 1], [9472, 2185, 1], [9472, 2186, 1], [9472, 2187, 1], [9472, 2188, 1], [9472, 2189, 1], [9472, 2190, 1], [9472, 2191, 1], [9472, 2192, 1], [9472, 2193, 1], [9472, 2194, 1], [9472, 2195, 1], [9472, 2196, 1], [9472, 2197, 1], [9472, 2198, 1], [9472, 2199, 1], [9472, 2200, 1], [9472, 2201, 1], [9472, 2202, 1], [9472, 2203, 1], [9472, 2204, 1], [9472, 2205, 1], [9472, 2206, 1], [9472, 2207, 1], [9472, 2208, 1], [9472, 2209, 1], [9472, 2210, 1], [9472, 2211, 1], [9472, 2212, 1], [9472, 2213, 1], [9472, 2214, 1], [9472, 2215, 1], [9472, 2216, 1], [9472, 2217, 1], [9472, 2218, 1], [9472, 2219, 1], [9472, 2220, 1], [9472, 2221, 1], [9472, 2222, 1], [9472, 2223, 1], [9472, 2224, 1], [9472, 2225, 1], [9472, 2226, 1], [9472, 2227, 1], [9472, 2228, 1], [9472, 2229, 1], [9472, 2230, 1], [9472, 2231, 1], [9472, 2232, 1], [9472, 2233, 1], [9472, 2234, 1], [9472, 2235, 1], [9472, 2236, 1], [9472, 2237, 1], [9472, 2238, 1], [9472, 2239, 1], [9472, 2240, 1], [9472, 2241, 1], [9472, 2242, 1], [9472, 2243, 1], [9472, 2244, 1], [9472, 2245, 1], [9472, 2246, 1], [9472, 2247, 1], [9472, 2248, 1], [9472, 2249, 1], [9472, 2250, 1], [9472, 2251, 1], [9472, 2252, 1], [9472, 2253, 1], [9472, 2254, 1], [9472, 2255, 1], [9472, 2256, 1], [9472, 2257, 1], [9472, 2258, 1], [9472, 2259, 1], [9472, 2260, 1], [9472, 2261, 1], [9472, 2262, 1], [9472, 2263, 1], [9472, 2264, 1], [9472, 2265, 1], [9472, 2266, 1], [9472, 2267, 1], [9472, 2268, 1], [9472, 2269, 1], [9472, 2270, 1], [9472, 2271, 1], [9472, 2272, 1], [9472, 2273, 1], [9472, 2274, 1], [9472, 2275, 1], [9472, 2276, 1], [9472, 2277, 1], [9472, 2278, 1], [9472, 2279, 1], [9472, 2280, 1], [9472, 2281, 1], [9472, 2282, 1], [9472, 2283, 1], [9472, 2284, 1], [9472, 2285, 1], [9472, 2286, 1], [9472, 2287, 1], [9472, 2288, 1], [9472, 2289, 1], [9472, 2290, 1], [9472, 2291, 1], [9472, 2292, 1], [9472, 2293, 1], [9472, 2294, 1], [9472, 2295, 1], [9472, 2296, 1], [9472, 2297, 1], [9472, 2298, 1], [9472, 2299, 1], [9472, 2300, 1], [9472, 2301, 1], [9472, 2302, 1], [9472, 2303, 1], [9472, 2304, 1], [9472, 2305, 1], [9472, 2306, 1], [9472, 2307, 1], [9472, 2308, 1], [9472, 2309, 1], [9472, 2310, 1], [9472, 2311, 1], [9472, 2312, 1], [9472, 2313, 1], [9472, 2314, 1], [9472, 2315, 1], [9472, 2316, 1], [9472, 2317, 1], [9472, 2318, 1], [9472, 2319, 1], [9472, 2320, 1], [9472, 2321, 1], [9472, 2322, 1], [9472, 2323, 1], [9472, 2324, 1], [9472, 2325, 1], [9472, 2326, 1], [9472, 2327, 1], [9472, 2328, 1], [9472, 2329, 1], [9472, 2330, 1], [9472, 2331, 1], [9472, 2332, 1], [9472, 2333, 1], [9472, 2334, 1], [9472, 2335, 1], [9472, 2336, 1], [9472, 2337, 1], [9472, 2338, 1], [9472, 2339, 1], [9472, 2340, 1], [9472, 2341, 1], [9472, 2342, 1], [9472, 2343, 1], [9472, 2344, 1], [9472, 2345, 1], [9472, 2346, 1], [9472, 2347, 1], [9472, 2348, 1], [9472, 2349, 1], [9472, 2350, 1], [9472, 2351, 1], [9472, 2352, 1], [9472, 2353, 1], [9472, 2354, 1], [9472, 2355, 1], [9472, 2356, 1], [9472, 2357, 1], [9472, 2358, 1], [9472, 2359, 1], [9472, 2360, 1], [9472, 2361, 1], [9472, 2362, 1], [9472, 2363, 1], [9472, 2364, 1], [9472, 2365, 1], [9472, 2366, 1], [9472, 2367, 1], [9472, 2368, 1], [9472, 2369, 1], [9472, 2370, 1], [9472, 2371, 1], [9472, 2372, 1], [9472, 2373, 1], [9472, 2374, 1], [9472, 2375, 1], [9472, 2376, 1], [9472, 2377, 1], [9472, 2378, 1], [9472, 2379, 1], [9472, 2380, 1], [9472, 2381, 1], [9472, 2382, 1], [9472, 2383, 1], [9472, 2384, 1], [9472, 2385, 1], [9472, 2386, 1], [9472, 2387, 1], [9472, 2388, 1], [9472, 2389, 1], [9472, 2390, 1], [9472, 2391, 1], [9472, 2392, 1], [9472, 2393, 1], [9472, 2394, 1], [9472, 2395, 1], [9472, 2396, 1], [9472, 2397, 1], [9472, 2398, 1], [9472, 2399, 1], [9472, 2400, 1], [9472, 2401, 1], [9472, 2402, 1], [9472, 2403, 1], [9472, 2404, 1], [9472, 2405, 1], [9472, 2406, 1], [9472, 2407, 1], [9472, 2408, 1], [9472, 2409, 1], [9472, 2410, 1], [9472, 2411, 1], [9472, 2412, 1], [9472, 2413, 1], [9472, 2414, 1], [9472, 2415, 1], [9472, 2416, 1], [9472, 2417, 1], [9472, 2418, 1], [9472, 2419, 1], [9472, 2420, 1], [9472, 2421, 1], [9472, 2422, 1], [9472, 2423, 1], [9472, 2424, 1], [9472, 2425, 1], [9472, 2426, 1], [9472, 2427, 1], [9472, 2428, 1], [9472, 2429, 1], [9472, 2430, 1], [9472, 2431, 1], [9472, 2432, 1], [9472, 2433, 1], [9472, 2434, 1], [9472, 2435, 1], [9472, 2436, 1], [9472, 2437, 1], [9472, 2438, 1], [9472, 2439, 1], [9472, 2440, 1], [9472, 2441, 1], [9472, 2442, 1], [9472, 2443, 1], [951, 9470, 1], [9470, 1022, 1], [9470, 8044, 1], [9470, 8045, 1], [9470, 8046, 1], [9470, 8047, 1], [9470, 8048, 1], [9470, 8049, 1], [9470, 8050, 1], [9470, 8051, 1], [9470, 8052, 1], [9470, 8053, 1], [9470, 8054, 1], [9470, 8055, 1], [9470, 8056, 1], [9470, 8057, 1], [9470, 8058, 1], [9470, 8059, 1], [9470, 8060, 1], [9470, 8061, 1], [9470, 8062, 1], [9470, 8063, 1], [9470, 8064, 1], [9470, 8065, 1], [9470, 8066, 1], [9470, 8067, 1], [9470, 8068, 1], [9470, 8069, 1], [9470, 8070, 1], [9470, 8071, 1], [9470, 8072, 1], [9470, 8073, 1], [9470, 8074, 1], [9470, 8075, 1], [9470, 8076, 1], [9470, 8077, 1], [9470, 8078, 1], [9470, 8079, 1], [9470, 8080, 1], [9470, 8081, 1], [9470, 8082, 1], [9470, 8083, 1], [9470, 8084, 1], [9470, 8085, 1], [9470, 8086, 1], [9470, 8087, 1], [9470, 8088, 1], [9470, 8089, 1], [9470, 8090, 1], [9470, 8091, 1], [9470, 8092, 1], [9470, 8093, 1], [9470, 8094, 1], [9470, 8095, 1], [9470, 8096, 1], [9470, 8097, 1], [9470, 8098, 1], [9470, 8099, 1], [9470, 8100, 1], [9470, 8101, 1], [9470, 8102, 1], [9470, 8103, 1], [9470, 8104, 1], [9470, 8105, 1], [9470, 8106, 1], [9470, 8107, 1], [9470, 8108, 1], [9470, 8109, 1], [9470, 8110, 1], [9470, 8111, 1], [9470, 8112, 1], [9470, 8113, 1], [9470, 8114, 1], [9470, 8115, 1], [9470, 8116, 1], [9470, 8117, 1], [9470, 8118, 1], [9470, 8119, 1], [9470, 8120, 1], [9470, 8121, 1], [9470, 8122, 1], [9470, 8123, 1], [9470, 8124, 1], [9470, 8125, 1], [9470, 8126, 1], [9470, 8127, 1], [9470, 8128, 1], [9470, 8129, 1], [9470, 8130, 1], [9470, 8131, 1], [9470, 8132, 1], [9470, 8133, 1], [9470, 8134, 1], [9470, 8135, 1], [9470, 8136, 1], [9470, 8137, 1], [9470, 8138, 1], [9470, 8139, 1], [9470, 8140, 1], [9470, 8141, 1], [9470, 8142, 1], [9470, 8143, 1], [9470, 8144, 1], [9470, 8145, 1], [9470, 8146, 1], [9470, 8147, 1], [9470, 8148, 1], [9470, 8149, 1], [9470, 8150, 1], [9470, 8151, 1], [9470, 8152, 1], [9470, 8153, 1], [9470, 8154, 1], [9470, 8155, 1], [9470, 8156, 1], [9470, 8157, 1], [9470, 8158, 1], [9470, 8159, 1], [9470, 8160, 1], [9470, 8161, 1], [9470, 8162, 1], [9470, 8163, 1], [9470, 8164, 1], [9470, 8165, 1], [9470, 8166, 1], [9470, 8167, 1], [9470, 8168, 1], [9470, 8169, 1], [9470, 8170, 1], [9470, 8171, 1], [9470, 8172, 1], [9470, 8173, 1], [9470, 8174, 1], [9470, 8175, 1], [9470, 8176, 1], [9470, 8177, 1], [9470, 8178, 1], [9470, 8179, 1], [9470, 8180, 1], [9470, 8181, 1], [9470, 8182, 1], [9470, 8183, 1], [9470, 8184, 1], [9470, 8185, 1], [9470, 8186, 1], [9470, 8187, 1], [9470, 8188, 1], [9470, 8189, 1], [9470, 8190, 1], [9470, 8191, 1], [9470, 8192, 1], [9470, 8193, 1], [9470, 8194, 1], [9470, 8195, 1], [9470, 8196, 1], [9470, 8197, 1], [9470, 8198, 1], [9470, 8199, 1], [9470, 8200, 1], [9470, 8201, 1], [9470, 8202, 1], [9470, 8203, 1], [9470, 8204, 1], [9470, 8205, 1], [9470, 8206, 1], [9470, 8207, 1], [9470, 8208, 1], [9470, 8209, 1], [9470, 8210, 1], [9470, 8211, 1], [9470, 8212, 1], [9470, 8213, 1], [9470, 8214, 1], [9470, 8215, 1], [9470, 8216, 1], [9470, 8217, 1], [9470, 8218, 1], [9470, 8219, 1], [9470, 8220, 1], [9470, 8221, 1], [9470, 8222, 1], [9470, 8223, 1], [9470, 8224, 1], [9470, 8225, 1], [9470, 8226, 1], [9470, 8227, 1], [9470, 8228, 1], [9470, 8229, 1], [9470, 8230, 1], [9470, 8231, 1], [9470, 8232, 1], [9470, 8233, 1], [9470, 8234, 1], [9470, 8235, 1], [9470, 8236, 1], [9470, 8237, 1], [9470, 8238, 1], [9470, 8239, 1], [9470, 8240, 1], [9470, 8241, 1], [9470, 8242, 1], [9470, 8243, 1], [9470, 8244, 1], [9470, 8245, 1], [9470, 8246, 1], [9470, 8247, 1], [9470, 8248, 1], [9470, 8249, 1], [9470, 8250, 1], [9470, 8251, 1], [9470, 8252, 1], [9470, 8253, 1], [9470, 8254, 1], [9470, 8255, 1], [9470, 8256, 1], [9470, 8257, 1], [9470, 8258, 1], [9470, 8259, 1], [9470, 8260, 1], [9470, 8261, 1], [9470, 8262, 1], [9470, 8263, 1], [9470, 8264, 1], [9470, 8265, 1], [9470, 8266, 1], [9470, 8267, 1], [9470, 8268, 1], [9470, 8269, 1], [9470, 8270, 1], [9470, 8271, 1], [9470, 8272, 1], [9470, 8273, 1], [9470, 8274, 1], [9470, 8275, 1], [9470, 8276, 1], [9470, 8277, 1], [9470, 8278, 1], [9470, 8279, 1], [9470, 8280, 1], [9470, 8281, 1], [9470, 8282, 1], [9470, 8283, 1], [9470, 8284, 1], [9470, 8285, 1], [9470, 8286, 1], [9470, 8287, 1], [9470, 8288, 1], [9470, 8289, 1], [9470, 8290, 1], [9470, 8291, 1], [9470, 8292, 1], [9470, 8293, 1], [9470, 8294, 1], [9470, 8295, 1], [9470, 8296, 1], [9470, 8297, 1], [9470, 8298, 1], [9470, 8299, 1], [9470, 8300, 1], [9470, 8301, 1], [9470, 8302, 1], [9470, 8303, 1], [9470, 8304, 1], [9470, 8305, 1], [9470, 8306, 1], [9470, 8307, 1], [9470, 8308, 1], [9470, 8309, 1], [9470, 8310, 1], [9470, 8311, 1], [9470, 8312, 1], [9470, 8313, 1], [9470, 8314, 1], [9470, 8315, 1], [9470, 8316, 1], [9470, 8317, 1], [9470, 8318, 1], [9470, 8319, 1], [9470, 8320, 1], [9470, 8321, 1], [9470, 8322, 1], [9470, 8323, 1], [1033, 974, 1], [1033, 984, 1], [1033, 990, 1], [1033, 980, 1], [1033, 972, 1], [1033, 976, 1], [1033, 978, 1], [1033, 982, 1], [1033, 986, 1], [1033, 988, 1], [974, 975, 1], [789, 475, 1], [789, 780, 1], [475, 476, 1], [793, 200, 1], [200, 201, 1], [984, 985, 1], [993, 1038, 1], [549, 158, 1], [158, 159, 1], [1025, 1036, 1], [320, 425, 1], [425, 426, 1], [450, 482, 1], [450, 750, 1], [482, 483, 1], [961, 9449, 1], [990, 991, 1], [980, 981, 1], [395, 789, 1], [9466, 1020, 1], [9466, 8884, 1], [9466, 8885, 1], [9466, 8886, 1], [9466, 8887, 1], [9466, 8888, 1], [9466, 8889, 1], [9466, 8890, 1], [9466, 8891, 1], [9466, 8892, 1], [9466, 8893, 1], [9466, 8894, 1], [9466, 8895, 1], [9466, 8896, 1], [9466, 8897, 1], [9466, 8898, 1], [9466, 8899, 1], [9466, 8900, 1], [9466, 8901, 1], [9466, 8902, 1], [9466, 8903, 1], [9466, 8904, 1], [9466, 8905, 1], [9466, 8906, 1], [9466, 8907, 1], [9466, 8908, 1], [9466, 8909, 1], [9466, 8910, 1], [9466, 8911, 1], [9466, 8912, 1], [9466, 8913, 1], [9466, 8914, 1], [9466, 8915, 1], [9466, 8916, 1], [9466, 8917, 1], [9466, 8918, 1], [9466, 8919, 1], [9466, 8920, 1], [9466, 8921, 1], [9466, 8922, 1], [9466, 8923, 1], [9466, 8924, 1], [9466, 8925, 1], [9466, 8926, 1], [9466, 8927, 1], [9466, 8928, 1], [9466, 8929, 1], [9466, 8930, 1], [9466, 8931, 1], [9466, 8932, 1], [9466, 8933, 1], [9466, 8934, 1], [9466, 8935, 1], [9466, 8936, 1], [9466, 8937, 1], [9466, 8938, 1], [9466, 8939, 1], [9466, 8940, 1], [9466, 8941, 1], [9466, 8942, 1], [9466, 8943, 1], [9466, 8944, 1], [9466, 8945, 1], [9466, 8946, 1], [9466, 8947, 1], [9466, 8948, 1], [9466, 8949, 1], [9466, 8950, 1], [9466, 8951, 1], [9466, 8952, 1], [9466, 8953, 1], [9466, 8954, 1], [9466, 8955, 1], [9466, 8956, 1], [9466, 8957, 1], [9466, 8958, 1], [9466, 8959, 1], [9466, 8960, 1], [9466, 8961, 1], [9466, 8962, 1], [9466, 8963, 1], [9466, 8964, 1], [9466, 8965, 1], [9466, 8966, 1], [9466, 8967, 1], [9466, 8968, 1], [9466, 8969, 1], [9466, 8970, 1], [9466, 8971, 1], [9466, 8972, 1], [9466, 8973, 1], [9466, 8974, 1], [9466, 8975, 1], [9466, 8976, 1], [9466, 8977, 1], [9466, 8978, 1], [9466, 8979, 1], [9466, 8980, 1], [9466, 8981, 1], [9466, 8982, 1], [9466, 8983, 1], [9466, 8984, 1], [9466, 8985, 1], [9466, 8986, 1], [9466, 8987, 1], [9466, 8988, 1], [9466, 8989, 1], [9466, 8990, 1], [9466, 8991, 1], [9466, 8992, 1], [9466, 8993, 1], [9466, 8994, 1], [9466, 8995, 1], [9466, 8996, 1], [9466, 8997, 1], [9466, 8998, 1], [9466, 8999, 1], [9466, 9000, 1], [9466, 9001, 1], [9466, 9002, 1], [9466, 9003, 1], [9466, 9004, 1], [9466, 9005, 1], [9466, 9006, 1], [9466, 9007, 1], [9466, 9008, 1], [9466, 9009, 1], [9466, 9010, 1], [9466, 9011, 1], [9466, 9012, 1], [9466, 9013, 1], [9466, 9014, 1], [9466, 9015, 1], [9466, 9016, 1], [9466, 9017, 1], [9466, 9018, 1], [9466, 9019, 1], [9466, 9020, 1], [9466, 9021, 1], [9466, 9022, 1], [9466, 9023, 1], [9466, 9024, 1], [9466, 9025, 1], [9466, 9026, 1], [9466, 9027, 1], [9466, 9028, 1], [9466, 9029, 1], [9466, 9030, 1], [9466, 9031, 1], [9466, 9032, 1], [9466, 9033, 1], [9466, 9034, 1], [9466, 9035, 1], [9466, 9036, 1], [9466, 9037, 1], [9466, 9038, 1], [9466, 9039, 1], [9466, 9040, 1], [9466, 9041, 1], [9466, 9042, 1], [9466, 9043, 1], [9466, 9044, 1], [9466, 9045, 1], [9466, 9046, 1], [9466, 9047, 1], [9466, 9048, 1], [9466, 9049, 1], [9466, 9050, 1], [9466, 9051, 1], [9466, 9052, 1], [9466, 9053, 1], [9466, 9054, 1], [9466, 9055, 1], [9466, 9056, 1], [9466, 9057, 1], [9466, 9058, 1], [9466, 9059, 1], [9466, 9060, 1], [9466, 9061, 1], [9466, 9062, 1], [9466, 9063, 1], [9466, 9064, 1], [9466, 9065, 1], [9466, 9066, 1], [9466, 9067, 1], [9466, 9068, 1], [9466, 9069, 1], [9466, 9070, 1], [9466, 9071, 1], [9466, 9072, 1], [9466, 9073, 1], [9466, 9074, 1], [9466, 9075, 1], [9466, 9076, 1], [9466, 9077, 1], [9466, 9078, 1], [9466, 9079, 1], [9466, 9080, 1], [9466, 9081, 1], [9466, 9082, 1], [9466, 9083, 1], [9466, 9084, 1], [9466, 9085, 1], [9466, 9086, 1], [9466, 9087, 1], [9466, 9088, 1], [9466, 9089, 1], [9466, 9090, 1], [9466, 9091, 1], [9466, 9092, 1], [9466, 9093, 1], [9466, 9094, 1], [9466, 9095, 1], [9466, 9096, 1], [9466, 9097, 1], [9466, 9098, 1], [9466, 9099, 1], [9466, 9100, 1], [9466, 9101, 1], [9466, 9102, 1], [9466, 9103, 1], [9466, 9104, 1], [9466, 9105, 1], [9466, 9106, 1], [9466, 9107, 1], [9466, 9108, 1], [9466, 9109, 1], [9466, 9110, 1], [9466, 9111, 1], [9466, 9112, 1], [9466, 9113, 1], [9466, 9114, 1], [9466, 9115, 1], [9466, 9116, 1], [9466, 9117, 1], [9466, 9118, 1], [9466, 9119, 1], [9466, 9120, 1], [9466, 9121, 1], [9466, 9122, 1], [9466, 9123, 1], [9466, 9124, 1], [9466, 9125, 1], [9466, 9126, 1], [9466, 9127, 1], [9466, 9128, 1], [9466, 9129, 1], [9466, 9130, 1], [9466, 9131, 1], [9466, 9132, 1], [9466, 9133, 1], [9466, 9134, 1], [9466, 9135, 1], [9466, 9136, 1], [9466, 9137, 1], [9466, 9138, 1], [9466, 9139, 1], [9466, 9140, 1], [9466, 9141, 1], [9466, 9142, 1], [9466, 9143, 1], [9466, 9144, 1], [9466, 9145, 1], [9466, 9146, 1], [9466, 9147, 1], [9466, 9148, 1], [9466, 9149, 1], [9466, 9150, 1], [9466, 9151, 1], [9466, 9152, 1], [9466, 9153, 1], [9466, 9154, 1], [9466, 9155, 1], [9466, 9156, 1], [9466, 9157, 1], [9466, 9158, 1], [9466, 9159, 1], [9466, 9160, 1], [9466, 9161, 1], [9466, 9162, 1], [9466, 9163, 1], [1020, 1021, 1], [321, 408, 1], [609, 500, 1], [500, 839, 1], [500, 576, 1], [199, 60, 1], [60, 61, 1], [931, 1034, 1], [953, 9453, 1], [9453, 1000, 1], [9453, 7064, 1], [9453, 7065, 1], [9453, 7066, 1], [9453, 7067, 1], [9453, 7068, 1], [9453, 7069, 1], [9453, 7070, 1], [9453, 7071, 1], [9453, 7072, 1], [9453, 7073, 1], [9453, 7074, 1], [9453, 7075, 1], [9453, 7076, 1], [9453, 7077, 1], [9453, 7078, 1], [9453, 7079, 1], [9453, 7080, 1], [9453, 7081, 1], [9453, 7082, 1], [9453, 7083, 1], [9453, 7084, 1], [9453, 7085, 1], [9453, 7086, 1], [9453, 7087, 1], [9453, 7088, 1], [9453, 7089, 1], [9453, 7090, 1], [9453, 7091, 1], [9453, 7092, 1], [9453, 7093, 1], [9453, 7094, 1], [9453, 7095, 1], [9453, 7096, 1], [9453, 7097, 1], [9453, 7098, 1], [9453, 7099, 1], [9453, 7100, 1], [9453, 7101, 1], [9453, 7102, 1], [9453, 7103, 1], [9453, 7104, 1], [9453, 7105, 1], [9453, 7106, 1], [9453, 7107, 1], [9453, 7108, 1], [9453, 7109, 1], [9453, 7110, 1], [9453, 7111, 1], [9453, 7112, 1], [9453, 7113, 1], [9453, 7114, 1], [9453, 7115, 1], [9453, 7116, 1], [9453, 7117, 1], [9453, 7118, 1], [9453, 7119, 1], [9453, 7120, 1], [9453, 7121, 1], [9453, 7122, 1], [9453, 7123, 1], [9453, 7124, 1], [9453, 7125, 1], [9453, 7126, 1], [9453, 7127, 1], [9453, 7128, 1], [9453, 7129, 1], [9453, 7130, 1], [9453, 7131, 1], [9453, 7132, 1], [9453, 7133, 1], [9453, 7134, 1], [9453, 7135, 1], [9453, 7136, 1], [9453, 7137, 1], [9453, 7138, 1], [9453, 7139, 1], [9453, 7140, 1], [9453, 7141, 1], [9453, 7142, 1], [9453, 7143, 1], [9453, 7144, 1], [9453, 7145, 1], [9453, 7146, 1], [9453, 7147, 1], [9453, 7148, 1], [9453, 7149, 1], [9453, 7150, 1], [9453, 7151, 1], [9453, 7152, 1], [9453, 7153, 1], [9453, 7154, 1], [9453, 7155, 1], [9453, 7156, 1], [9453, 7157, 1], [9453, 7158, 1], [9453, 7159, 1], [9453, 7160, 1], [9453, 7161, 1], [9453, 7162, 1], [9453, 7163, 1], [9453, 7164, 1], [9453, 7165, 1], [9453, 7166, 1], [9453, 7167, 1], [9453, 7168, 1], [9453, 7169, 1], [9453, 7170, 1], [9453, 7171, 1], [9453, 7172, 1], [9453, 7173, 1], [9453, 7174, 1], [9453, 7175, 1], [9453, 7176, 1], [9453, 7177, 1], [9453, 7178, 1], [9453, 7179, 1], [9453, 7180, 1], [9453, 7181, 1], [9453, 7182, 1], [9453, 7183, 1], [9453, 7184, 1], [9453, 7185, 1], [9453, 7186, 1], [9453, 7187, 1], [9453, 7188, 1], [9453, 7189, 1], [9453, 7190, 1], [9453, 7191, 1], [9453, 7192, 1], [9453, 7193, 1], [9453, 7194, 1], [9453, 7195, 1], [9453, 7196, 1], [9453, 7197, 1], [9453, 7198, 1], [9453, 7199, 1], [9453, 7200, 1], [9453, 7201, 1], [9453, 7202, 1], [9453, 7203, 1], [9453, 7484, 1], [9453, 7485, 1], [9453, 7486, 1], [9453, 7487, 1], [9453, 7488, 1], [9453, 7489, 1], [9453, 7490, 1], [9453, 7491, 1], [9453, 7492, 1], [9453, 7493, 1], [9453, 7494, 1], [9453, 7495, 1], [9453, 7496, 1], [9453, 7497, 1], [9453, 7498, 1], [9453, 7499, 1], [9453, 7500, 1], [9453, 7501, 1], [9453, 7502, 1], [9453, 7503, 1], [9453, 7504, 1], [9453, 7505, 1], [9453, 7506, 1], [9453, 7507, 1], [9453, 7508, 1], [9453, 7509, 1], [9453, 7510, 1], [9453, 7511, 1], [9453, 7512, 1], [9453, 7513, 1], [9453, 7514, 1], [9453, 7515, 1], [9453, 7516, 1], [9453, 7517, 1], [9453, 7518, 1], [9453, 7519, 1], [9453, 7520, 1], [9453, 7521, 1], [9453, 7522, 1], [9453, 7523, 1], [9453, 7524, 1], [9453, 7525, 1], [9453, 7526, 1], [9453, 7527, 1], [9453, 7528, 1], [9453, 7529, 1], [9453, 7530, 1], [9453, 7531, 1], [9453, 7532, 1], [9453, 7533, 1], [9453, 7534, 1], [9453, 7535, 1], [9453, 7536, 1], [9453, 7537, 1], [9453, 7538, 1], [9453, 7539, 1], [9453, 7540, 1], [9453, 7541, 1], [9453, 7542, 1], [9453, 7543, 1], [9453, 7544, 1], [9453, 7545, 1], [9453, 7546, 1], [9453, 7547, 1], [9453, 7548, 1], [9453, 7549, 1], [9453, 7550, 1], [9453, 7551, 1], [9453, 7552, 1], [9453, 7553, 1], [9453, 7554, 1], [9453, 7555, 1], [9453, 7556, 1], [9453, 7557, 1], [9453, 7558, 1], [9453, 7559, 1], [9453, 7560, 1], [9453, 7561, 1], [9453, 7562, 1], [9453, 7563, 1], [9453, 7564, 1], [9453, 7565, 1], [9453, 7566, 1], [9453, 7567, 1], [9453, 7568, 1], [9453, 7569, 1], [9453, 7570, 1], [9453, 7571, 1], [9453, 7572, 1], [9453, 7573, 1], [9453, 7574, 1], [9453, 7575, 1], [9453, 7576, 1], [9453, 7577, 1], [9453, 7578, 1], [9453, 7579, 1], [9453, 7580, 1], [9453, 7581, 1], [9453, 7582, 1], [9453, 7583, 1], [9453, 7584, 1], [9453, 7585, 1], [9453, 7586, 1], [9453, 7587, 1], [9453, 7588, 1], [9453, 7589, 1], [9453, 7590, 1], [9453, 7591, 1], [9453, 7592, 1], [9453, 7593, 1], [9453, 7594, 1], [9453, 7595, 1], [9453, 7596, 1], [9453, 7597, 1], [9453, 7598, 1], [9453, 7599, 1], [9453, 7600, 1], [9453, 7601, 1], [9453, 7602, 1], [9453, 7603, 1], [9453, 7604, 1], [9453, 7605, 1], [9453, 7606, 1], [9453, 7607, 1], [9453, 7608, 1], [9453, 7609, 1], [9453, 7610, 1], [9453, 7611, 1], [9453, 7612, 1], [9453, 7613, 1], [9453, 7614, 1], [9453, 7615, 1], [9453, 7616, 1], [9453, 7617, 1], [9453, 7618, 1], [9453, 7619, 1], [9453, 7620, 1], [9453, 7621, 1], [9453, 7622, 1], [9453, 7623, 1], [987, 9462, 1], [9462, 926, 1], [9462, 6924, 1], [9462, 6925, 1], [9462, 6926, 1], [9462, 6927, 1], [9462, 6928, 1], [9462, 6929, 1], [9462, 6930, 1], [9462, 6931, 1], [9462, 6932, 1], [9462, 6933, 1], [9462, 6934, 1], [9462, 6935, 1], [9462, 6936, 1], [9462, 6937, 1], [9462, 6938, 1], [9462, 6939, 1], [9462, 6940, 1], [9462, 6941, 1], [9462, 6942, 1], [9462, 6943, 1], [9462, 6944, 1], [9462, 6945, 1], [9462, 6946, 1], [9462, 6947, 1], [9462, 6948, 1], [9462, 6949, 1], [9462, 6950, 1], [9462, 6951, 1], [9462, 6952, 1], [9462, 6953, 1], [9462, 6954, 1], [9462, 6955, 1], [9462, 6956, 1], [9462, 6957, 1], [9462, 6958, 1], [9462, 6959, 1], [9462, 6960, 1], [9462, 6961, 1], [9462, 6962, 1], [9462, 6963, 1], [9462, 6964, 1], [9462, 6965, 1], [9462, 6966, 1], [9462, 6967, 1], [9462, 6968, 1], [9462, 6969, 1], [9462, 6970, 1], [9462, 6971, 1], [9462, 6972, 1], [9462, 6973, 1], [9462, 6974, 1], [9462, 6975, 1], [9462, 6976, 1], [9462, 6977, 1], [9462, 6978, 1], [9462, 6979, 1], [9462, 6980, 1], [9462, 6981, 1], [9462, 6982, 1], [9462, 6983, 1], [9462, 6984, 1], [9462, 6985, 1], [9462, 6986, 1], [9462, 6987, 1], [9462, 6988, 1], [9462, 6989, 1], [9462, 6990, 1], [9462, 6991, 1], [9462, 6992, 1], [9462, 6993, 1], [9462, 6994, 1], [9462, 6995, 1], [9462, 6996, 1], [9462, 6997, 1], [9462, 6998, 1], [9462, 6999, 1], [9462, 7000, 1], [9462, 7001, 1], [9462, 7002, 1], [9462, 7003, 1], [9462, 7004, 1], [9462, 7005, 1], [9462, 7006, 1], [9462, 7007, 1], [9462, 7008, 1], [9462, 7009, 1], [9462, 7010, 1], [9462, 7011, 1], [9462, 7012, 1], [9462, 7013, 1], [9462, 7014, 1], [9462, 7015, 1], [9462, 7016, 1], [9462, 7017, 1], [9462, 7018, 1], [9462, 7019, 1], [9462, 7020, 1], [9462, 7021, 1], [9462, 7022, 1], [9462, 7023, 1], [9462, 7024, 1], [9462, 7025, 1], [9462, 7026, 1], [9462, 7027, 1], [9462, 7028, 1], [9462, 7029, 1], [9462, 7030, 1], [9462, 7031, 1], [9462, 7032, 1], [9462, 7033, 1], [9462, 7034, 1], [9462, 7035, 1], [9462, 7036, 1], [9462, 7037, 1], [9462, 7038, 1], [9462, 7039, 1], [9462, 7040, 1], [9462, 7041, 1], [9462, 7042, 1], [9462, 7043, 1], [9462, 7044, 1], [9462, 7045, 1], [9462, 7046, 1], [9462, 7047, 1], [9462, 7048, 1], [9462, 7049, 1], [9462, 7050, 1], [9462, 7051, 1], [9462, 7052, 1], [9462, 7053, 1], [9462, 7054, 1], [9462, 7055, 1], [9462, 7056, 1], [9462, 7057, 1], [9462, 7058, 1], [9462, 7059, 1], [9462, 7060, 1], [9462, 7061, 1], [9462, 7062, 1], [9462, 7063, 1], [9462, 7624, 1], [9462, 7625, 1], [9462, 7626, 1], [9462, 7627, 1], [9462, 7628, 1], [9462, 7629, 1], [9462, 7630, 1], [9462, 7631, 1], [9462, 7632, 1], [9462, 7633, 1], [9462, 7634, 1], [9462, 7635, 1], [9462, 7636, 1], [9462, 7637, 1], [9462, 7638, 1], [9462, 7639, 1], [9462, 7640, 1], [9462, 7641, 1], [9462, 7642, 1], [9462, 7643, 1], [9462, 7644, 1], [9462, 7645, 1], [9462, 7646, 1], [9462, 7647, 1], [9462, 7648, 1], [9462, 7649, 1], [9462, 7650, 1], [9462, 7651, 1], [9462, 7652, 1], [9462, 7653, 1], [9462, 7654, 1], [9462, 7655, 1], [9462, 7656, 1], [9462, 7657, 1], [9462, 7658, 1], [9462, 7659, 1], [9462, 7660, 1], [9462, 7661, 1], [9462, 7662, 1], [9462, 7663, 1], [9462, 7664, 1], [9462, 7665, 1], [9462, 7666, 1], [9462, 7667, 1], [9462, 7668, 1], [9462, 7669, 1], [9462, 7670, 1], [9462, 7671, 1], [9462, 7672, 1], [9462, 7673, 1], [9462, 7674, 1], [9462, 7675, 1], [9462, 7676, 1], [9462, 7677, 1], [9462, 7678, 1], [9462, 7679, 1], [9462, 7680, 1], [9462, 7681, 1], [9462, 7682, 1], [9462, 7683, 1], [9462, 7684, 1], [9462, 7685, 1], [9462, 7686, 1], [9462, 7687, 1], [9462, 7688, 1], [9462, 7689, 1], [9462, 7690, 1], [9462, 7691, 1], [9462, 7692, 1], [9462, 7693, 1], [9462, 7694, 1], [9462, 7695, 1], [9462, 7696, 1], [9462, 7697, 1], [9462, 7698, 1], [9462, 7699, 1], [9462, 7700, 1], [9462, 7701, 1], [9462, 7702, 1], [9462, 7703, 1], [9462, 7704, 1], [9462, 7705, 1], [9462, 7706, 1], [9462, 7707, 1], [9462, 7708, 1], [9462, 7709, 1], [9462, 7710, 1], [9462, 7711, 1], [9462, 7712, 1], [9462, 7713, 1], [9462, 7714, 1], [9462, 7715, 1], [9462, 7716, 1], [9462, 7717, 1], [9462, 7718, 1], [9462, 7719, 1], [9462, 7720, 1], [9462, 7721, 1], [9462, 7722, 1], [9462, 7723, 1], [9462, 7724, 1], [9462, 7725, 1], [9462, 7726, 1], [9462, 7727, 1], [9462, 7728, 1], [9462, 7729, 1], [9462, 7730, 1], [9462, 7731, 1], [9462, 7732, 1], [9462, 7733, 1], [9462, 7734, 1], [9462, 7735, 1], [9462, 7736, 1], [9462, 7737, 1], [9462, 7738, 1], [9462, 7739, 1], [9462, 7740, 1], [9462, 7741, 1], [9462, 7742, 1], [9462, 7743, 1], [9462, 7744, 1], [9462, 7745, 1], [9462, 7746, 1], [9462, 7747, 1], [9462, 7748, 1], [9462, 7749, 1], [9462, 7750, 1], [9462, 7751, 1], [9462, 7752, 1], [9462, 7753, 1], [9462, 7754, 1], [9462, 7755, 1], [9462, 7756, 1], [9462, 7757, 1], [9462, 7758, 1], [9462, 7759, 1], [9462, 7760, 1], [9462, 7761, 1], [9462, 7762, 1], [9462, 7763, 1], [965, 9452, 1], [9452, 1010, 1], [9452, 2864, 1], [9452, 2865, 1], [9452, 2866, 1], [9452, 2867, 1], [9452, 2868, 1], [9452, 2869, 1], [9452, 2870, 1], [9452, 2871, 1], [9452, 2872, 1], [9452, 2873, 1], [9452, 2874, 1], [9452, 2875, 1], [9452, 2876, 1], [9452, 2877, 1], [9452, 2878, 1], [9452, 2879, 1], [9452, 2880, 1], [9452, 2881, 1], [9452, 2882, 1], [9452, 2883, 1], [9452, 2884, 1], [9452, 2885, 1], [9452, 2886, 1], [9452, 2887, 1], [9452, 2888, 1], [9452, 2889, 1], [9452, 2890, 1], [9452, 2891, 1], [9452, 2892, 1], [9452, 2893, 1], [9452, 2894, 1], [9452, 2895, 1], [9452, 2896, 1], [9452, 2897, 1], [9452, 2898, 1], [9452, 2899, 1], [9452, 2900, 1], [9452, 2901, 1], [9452, 2902, 1], [9452, 2903, 1], [9452, 2904, 1], [9452, 2905, 1], [9452, 2906, 1], [9452, 2907, 1], [9452, 2908, 1], [9452, 2909, 1], [9452, 2910, 1], [9452, 2911, 1], [9452, 2912, 1], [9452, 2913, 1], [9452, 2914, 1], [9452, 2915, 1], [9452, 2916, 1], [9452, 2917, 1], [9452, 2918, 1], [9452, 2919, 1], [9452, 2920, 1], [9452, 2921, 1], [9452, 2922, 1], [9452, 2923, 1], [9452, 2924, 1], [9452, 2925, 1], [9452, 2926, 1], [9452, 2927, 1], [9452, 2928, 1], [9452, 2929, 1], [9452, 2930, 1], [9452, 2931, 1], [9452, 2932, 1], [9452, 2933, 1], [9452, 2934, 1], [9452, 2935, 1], [9452, 2936, 1], [9452, 2937, 1], [9452, 2938, 1], [9452, 2939, 1], [9452, 2940, 1], [9452, 2941, 1], [9452, 2942, 1], [9452, 2943, 1], [9452, 2944, 1], [9452, 2945, 1], [9452, 2946, 1], [9452, 2947, 1], [9452, 2948, 1], [9452, 2949, 1], [9452, 2950, 1], [9452, 2951, 1], [9452, 2952, 1], [9452, 2953, 1], [9452, 2954, 1], [9452, 2955, 1], [9452, 2956, 1], [9452, 2957, 1], [9452, 2958, 1], [9452, 2959, 1], [9452, 2960, 1], [9452, 2961, 1], [9452, 2962, 1], [9452, 2963, 1], [9452, 2964, 1], [9452, 2965, 1], [9452, 2966, 1], [9452, 2967, 1], [9452, 2968, 1], [9452, 2969, 1], [9452, 2970, 1], [9452, 2971, 1], [9452, 2972, 1], [9452, 2973, 1], [9452, 2974, 1], [9452, 2975, 1], [9452, 2976, 1], [9452, 2977, 1], [9452, 2978, 1], [9452, 2979, 1], [9452, 2980, 1], [9452, 2981, 1], [9452, 2982, 1], [9452, 2983, 1], [9452, 2984, 1], [9452, 2985, 1], [9452, 2986, 1], [9452, 2987, 1], [9452, 2988, 1], [9452, 2989, 1], [9452, 2990, 1], [9452, 2991, 1], [9452, 2992, 1], [9452, 2993, 1], [9452, 2994, 1], [9452, 2995, 1], [9452, 2996, 1], [9452, 2997, 1], [9452, 2998, 1], [9452, 2999, 1], [9452, 3000, 1], [9452, 3001, 1], [9452, 3002, 1], [9452, 3003, 1], [9452, 3284, 1], [9452, 3285, 1], [9452, 3286, 1], [9452, 3287, 1], [9452, 3288, 1], [9452, 3289, 1], [9452, 3290, 1], [9452, 3291, 1], [9452, 3292, 1], [9452, 3293, 1], [9452, 3294, 1], [9452, 3295, 1], [9452, 3296, 1], [9452, 3297, 1], [9452, 3298, 1], [9452, 3299, 1], [9452, 3300, 1], [9452, 3301, 1], [9452, 3302, 1], [9452, 3303, 1], [9452, 3304, 1], [9452, 3305, 1], [9452, 3306, 1], [9452, 3307, 1], [9452, 3308, 1], [9452, 3309, 1], [9452, 3310, 1], [9452, 3311, 1], [9452, 3312, 1], [9452, 3313, 1], [9452, 3314, 1], [9452, 3315, 1], [9452, 3316, 1], [9452, 3317, 1], [9452, 3318, 1], [9452, 3319, 1], [9452, 3320, 1], [9452, 3321, 1], [9452, 3322, 1], [9452, 3323, 1], [9452, 3324, 1], [9452, 3325, 1], [9452, 3326, 1], [9452, 3327, 1], [9452, 3328, 1], [9452, 3329, 1], [9452, 3330, 1], [9452, 3331, 1], [9452, 3332, 1], [9452, 3333, 1], [9452, 3334, 1], [9452, 3335, 1], [9452, 3336, 1], [9452, 3337, 1], [9452, 3338, 1], [9452, 3339, 1], [9452, 3340, 1], [9452, 3341, 1], [9452, 3342, 1], [9452, 3343, 1], [9452, 3344, 1], [9452, 3345, 1], [9452, 3346, 1], [9452, 3347, 1], [9452, 3348, 1], [9452, 3349, 1], [9452, 3350, 1], [9452, 3351, 1], [9452, 3352, 1], [9452, 3353, 1], [9452, 3354, 1], [9452, 3355, 1], [9452, 3356, 1], [9452, 3357, 1], [9452, 3358, 1], [9452, 3359, 1], [9452, 3360, 1], [9452, 3361, 1], [9452, 3362, 1], [9452, 3363, 1], [9452, 3364, 1], [9452, 3365, 1], [9452, 3366, 1], [9452, 3367, 1], [9452, 3368, 1], [9452, 3369, 1], [9452, 3370, 1], [9452, 3371, 1], [9452, 3372, 1], [9452, 3373, 1], [9452, 3374, 1], [9452, 3375, 1], [9452, 3376, 1], [9452, 3377, 1], [9452, 3378, 1], [9452, 3379, 1], [9452, 3380, 1], [9452, 3381, 1], [9452, 3382, 1], [9452, 3383, 1], [9452, 3384, 1], [9452, 3385, 1], [9452, 3386, 1], [9452, 3387, 1], [9452, 3388, 1], [9452, 3389, 1], [9452, 3390, 1], [9452, 3391, 1], [9452, 3392, 1], [9452, 3393, 1], [9452, 3394, 1], [9452, 3395, 1], [9452, 3396, 1], [9452, 3397, 1], [9452, 3398, 1], [9452, 3399, 1], [9452, 3400, 1], [9452, 3401, 1], [9452, 3402, 1], [9452, 3403, 1], [9452, 3404, 1], [9452, 3405, 1], [9452, 3406, 1], [9452, 3407, 1], [9452, 3408, 1], [9452, 3409, 1], [9452, 3410, 1], [9452, 3411, 1], [9452, 3412, 1], [9452, 3413, 1], [9452, 3414, 1], [9452, 3415, 1], [9452, 3416, 1], [9452, 3417, 1], [9452, 3418, 1], [9452, 3419, 1], [9452, 3420, 1], [9452, 3421, 1], [9452, 3422, 1], [9452, 3423, 1], [59, 451, 1], [59, 397, 1], [59, 765, 1], [451, 452, 1], [1030, 1031, 1], [955, 9450, 1], [9450, 994, 1], [9450, 8744, 1], [9450, 8745, 1], [9450, 8746, 1], [9450, 8747, 1], [9450, 8748, 1], [9450, 8749, 1], [9450, 8750, 1], [9450, 8751, 1], [9450, 8752, 1], [9450, 8753, 1], [9450, 8754, 1], [9450, 8755, 1], [9450, 8756, 1], [9450, 8757, 1], [9450, 8758, 1], [9450, 8759, 1], [9450, 8760, 1], [9450, 8761, 1], [9450, 8762, 1], [9450, 8763, 1], [9450, 8764, 1], [9450, 8765, 1], [9450, 8766, 1], [9450, 8767, 1], [9450, 8768, 1], [9450, 8769, 1], [9450, 8770, 1], [9450, 8771, 1], [9450, 8772, 1], [9450, 8773, 1], [9450, 8774, 1], [9450, 8775, 1], [9450, 8776, 1], [9450, 8777, 1], [9450, 8778, 1], [9450, 8779, 1], [9450, 8780, 1], [9450, 8781, 1], [9450, 8782, 1], [9450, 8783, 1], [9450, 8784, 1], [9450, 8785, 1], [9450, 8786, 1], [9450, 8787, 1], [9450, 8788, 1], [9450, 8789, 1], [9450, 8790, 1], [9450, 8791, 1], [9450, 8792, 1], [9450, 8793, 1], [9450, 8794, 1], [9450, 8795, 1], [9450, 8796, 1], [9450, 8797, 1], [9450, 8798, 1], [9450, 8799, 1], [9450, 8800, 1], [9450, 8801, 1], [9450, 8802, 1], [9450, 8803, 1], [9450, 8804, 1], [9450, 8805, 1], [9450, 8806, 1], [9450, 8807, 1], [9450, 8808, 1], [9450, 8809, 1], [9450, 8810, 1], [9450, 8811, 1], [9450, 8812, 1], [9450, 8813, 1], [9450, 8814, 1], [9450, 8815, 1], [9450, 8816, 1], [9450, 8817, 1], [9450, 8818, 1], [9450, 8819, 1], [9450, 8820, 1], [9450, 8821, 1], [9450, 8822, 1], [9450, 8823, 1], [9450, 8824, 1], [9450, 8825, 1], [9450, 8826, 1], [9450, 8827, 1], [9450, 8828, 1], [9450, 8829, 1], [9450, 8830, 1], [9450, 8831, 1], [9450, 8832, 1], [9450, 8833, 1], [9450, 8834, 1], [9450, 8835, 1], [9450, 8836, 1], [9450, 8837, 1], [9450, 8838, 1], [9450, 8839, 1], [9450, 8840, 1], [9450, 8841, 1], [9450, 8842, 1], [9450, 8843, 1], [9450, 8844, 1], [9450, 8845, 1], [9450, 8846, 1], [9450, 8847, 1], [9450, 8848, 1], [9450, 8849, 1], [9450, 8850, 1], [9450, 8851, 1], [9450, 8852, 1], [9450, 8853, 1], [9450, 8854, 1], [9450, 8855, 1], [9450, 8856, 1], [9450, 8857, 1], [9450, 8858, 1], [9450, 8859, 1], [9450, 8860, 1], [9450, 8861, 1], [9450, 8862, 1], [9450, 8863, 1], [9450, 8864, 1], [9450, 8865, 1], [9450, 8866, 1], [9450, 8867, 1], [9450, 8868, 1], [9450, 8869, 1], [9450, 8870, 1], [9450, 8871, 1], [9450, 8872, 1], [9450, 8873, 1], [9450, 8874, 1], [9450, 8875, 1], [9450, 8876, 1], [9450, 8877, 1], [9450, 8878, 1], [9450, 8879, 1], [9450, 8880, 1], [9450, 8881, 1], [9450, 8882, 1], [9450, 8883, 1], [9450, 9164, 1], [9450, 9165, 1], [9450, 9166, 1], [9450, 9167, 1], [9450, 9168, 1], [9450, 9169, 1], [9450, 9170, 1], [9450, 9171, 1], [9450, 9172, 1], [9450, 9173, 1], [9450, 9174, 1], [9450, 9175, 1], [9450, 9176, 1], [9450, 9177, 1], [9450, 9178, 1], [9450, 9179, 1], [9450, 9180, 1], [9450, 9181, 1], [9450, 9182, 1], [9450, 9183, 1], [9450, 9184, 1], [9450, 9185, 1], [9450, 9186, 1], [9450, 9187, 1], [9450, 9188, 1], [9450, 9189, 1], [9450, 9190, 1], [9450, 9191, 1], [9450, 9192, 1], [9450, 9193, 1], [9450, 9194, 1], [9450, 9195, 1], [9450, 9196, 1], [9450, 9197, 1], [9450, 9198, 1], [9450, 9199, 1], [9450, 9200, 1], [9450, 9201, 1], [9450, 9202, 1], [9450, 9203, 1], [9450, 9204, 1], [9450, 9205, 1], [9450, 9206, 1], [9450, 9207, 1], [9450, 9208, 1], [9450, 9209, 1], [9450, 9210, 1], [9450, 9211, 1], [9450, 9212, 1], [9450, 9213, 1], [9450, 9214, 1], [9450, 9215, 1], [9450, 9216, 1], [9450, 9217, 1], [9450, 9218, 1], [9450, 9219, 1], [9450, 9220, 1], [9450, 9221, 1], [9450, 9222, 1], [9450, 9223, 1], [9450, 9224, 1], [9450, 9225, 1], [9450, 9226, 1], [9450, 9227, 1], [9450, 9228, 1], [9450, 9229, 1], [9450, 9230, 1], [9450, 9231, 1], [9450, 9232, 1], [9450, 9233, 1], [9450, 9234, 1], [9450, 9235, 1], [9450, 9236, 1], [9450, 9237, 1], [9450, 9238, 1], [9450, 9239, 1], [9450, 9240, 1], [9450, 9241, 1], [9450, 9242, 1], [9450, 9243, 1], [9450, 9244, 1], [9450, 9245, 1], [9450, 9246, 1], [9450, 9247, 1], [9450, 9248, 1], [9450, 9249, 1], [9450, 9250, 1], [9450, 9251, 1], [9450, 9252, 1], [9450, 9253, 1], [9450, 9254, 1], [9450, 9255, 1], [9450, 9256, 1], [9450, 9257, 1], [9450, 9258, 1], [9450, 9259, 1], [9450, 9260, 1], [9450, 9261, 1], [9450, 9262, 1], [9450, 9263, 1], [9450, 9264, 1], [9450, 9265, 1], [9450, 9266, 1], [9450, 9267, 1], [9450, 9268, 1], [9450, 9269, 1], [9450, 9270, 1], [9450, 9271, 1], [9450, 9272, 1], [9450, 9273, 1], [9450, 9274, 1], [9450, 9275, 1], [9450, 9276, 1], [9450, 9277, 1], [9450, 9278, 1], [9450, 9279, 1], [9450, 9280, 1], [9450, 9281, 1], [9450, 9282, 1], [9450, 9283, 1], [9450, 9284, 1], [9450, 9285, 1], [9450, 9286, 1], [9450, 9287, 1], [9450, 9288, 1], [9450, 9289, 1], [9450, 9290, 1], [9450, 9291, 1], [9450, 9292, 1], [9450, 9293, 1], [9450, 9294, 1], [9450, 9295, 1], [9450, 9296, 1], [9450, 9297, 1], [9450, 9298, 1], [9450, 9299, 1], [9450, 9300, 1], [9450, 9301, 1], [9450, 9302, 1], [9450, 9303, 1], [9460, 922, 1], [9460, 5244, 1], [9460, 5245, 1], [9460, 5246, 1], [9460, 5247, 1], [9460, 5248, 1], [9460, 5249, 1], [9460, 5250, 1], [9460, 5251, 1], [9460, 5252, 1], [9460, 5253, 1], [9460, 5254, 1], [9460, 5255, 1], [9460, 5256, 1], [9460, 5257, 1], [9460, 5258, 1], [9460, 5259, 1], [9460, 5260, 1], [9460, 5261, 1], [9460, 5262, 1], [9460, 5263, 1], [9460, 5264, 1], [9460, 5265, 1], [9460, 5266, 1], [9460, 5267, 1], [9460, 5268, 1], [9460, 5269, 1], [9460, 5270, 1], [9460, 5271, 1], [9460, 5272, 1], [9460, 5273, 1], [9460, 5274, 1], [9460, 5275, 1], [9460, 5276, 1], [9460, 5277, 1], [9460, 5278, 1], [9460, 5279, 1], [9460, 5280, 1], [9460, 5281, 1], [9460, 5282, 1], [9460, 5283, 1], [9460, 5284, 1], [9460, 5285, 1], [9460, 5286, 1], [9460, 5287, 1], [9460, 5288, 1], [9460, 5289, 1], [9460, 5290, 1], [9460, 5291, 1], [9460, 5292, 1], [9460, 5293, 1], [9460, 5294, 1], [9460, 5295, 1], [9460, 5296, 1], [9460, 5297, 1], [9460, 5298, 1], [9460, 5299, 1], [9460, 5300, 1], [9460, 5301, 1], [9460, 5302, 1], [9460, 5303, 1], [9460, 5304, 1], [9460, 5305, 1], [9460, 5306, 1], [9460, 5307, 1], [9460, 5308, 1], [9460, 5309, 1], [9460, 5310, 1], [9460, 5311, 1], [9460, 5312, 1], [9460, 5313, 1], [9460, 5314, 1], [9460, 5315, 1], [9460, 5316, 1], [9460, 5317, 1], [9460, 5318, 1], [9460, 5319, 1], [9460, 5320, 1], [9460, 5321, 1], [9460, 5322, 1], [9460, 5323, 1], [9460, 5324, 1], [9460, 5325, 1], [9460, 5326, 1], [9460, 5327, 1], [9460, 5328, 1], [9460, 5329, 1], [9460, 5330, 1], [9460, 5331, 1], [9460, 5332, 1], [9460, 5333, 1], [9460, 5334, 1], [9460, 5335, 1], [9460, 5336, 1], [9460, 5337, 1], [9460, 5338, 1], [9460, 5339, 1], [9460, 5340, 1], [9460, 5341, 1], [9460, 5342, 1], [9460, 5343, 1], [9460, 5344, 1], [9460, 5345, 1], [9460, 5346, 1], [9460, 5347, 1], [9460, 5348, 1], [9460, 5349, 1], [9460, 5350, 1], [9460, 5351, 1], [9460, 5352, 1], [9460, 5353, 1], [9460, 5354, 1], [9460, 5355, 1], [9460, 5356, 1], [9460, 5357, 1], [9460, 5358, 1], [9460, 5359, 1], [9460, 5360, 1], [9460, 5361, 1], [9460, 5362, 1], [9460, 5363, 1], [9460, 5364, 1], [9460, 5365, 1], [9460, 5366, 1], [9460, 5367, 1], [9460, 5368, 1], [9460, 5369, 1], [9460, 5370, 1], [9460, 5371, 1], [9460, 5372, 1], [9460, 5373, 1], [9460, 5374, 1], [9460, 5375, 1], [9460, 5376, 1], [9460, 5377, 1], [9460, 5378, 1], [9460, 5379, 1], [9460, 5380, 1], [9460, 5381, 1], [9460, 5382, 1], [9460, 5383, 1], [9460, 5944, 1], [9460, 5945, 1], [9460, 5946, 1], [9460, 5947, 1], [9460, 5948, 1], [9460, 5949, 1], [9460, 5950, 1], [9460, 5951, 1], [9460, 5952, 1], [9460, 5953, 1], [9460, 5954, 1], [9460, 5955, 1], [9460, 5956, 1], [9460, 5957, 1], [9460, 5958, 1], [9460, 5959, 1], [9460, 5960, 1], [9460, 5961, 1], [9460, 5962, 1], [9460, 5963, 1], [9460, 5964, 1], [9460, 5965, 1], [9460, 5966, 1], [9460, 5967, 1], [9460, 5968, 1], [9460, 5969, 1], [9460, 5970, 1], [9460, 5971, 1], [9460, 5972, 1], [9460, 5973, 1], [9460, 5974, 1], [9460, 5975, 1], [9460, 5976, 1], [9460, 5977, 1], [9460, 5978, 1], [9460, 5979, 1], [9460, 5980, 1], [9460, 5981, 1], [9460, 5982, 1], [9460, 5983, 1], [9460, 5984, 1], [9460, 5985, 1], [9460, 5986, 1], [9460, 5987, 1], [9460, 5988, 1], [9460, 5989, 1], [9460, 5990, 1], [9460, 5991, 1], [9460, 5992, 1], [9460, 5993, 1], [9460, 5994, 1], [9460, 5995, 1], [9460, 5996, 1], [9460, 5997, 1], [9460, 5998, 1], [9460, 5999, 1], [9460, 6000, 1], [9460, 6001, 1], [9460, 6002, 1], [9460, 6003, 1], [9460, 6004, 1], [9460, 6005, 1], [9460, 6006, 1], [9460, 6007, 1], [9460, 6008, 1], [9460, 6009, 1], [9460, 6010, 1], [9460, 6011, 1], [9460, 6012, 1], [9460, 6013, 1], [9460, 6014, 1], [9460, 6015, 1], [9460, 6016, 1], [9460, 6017, 1], [9460, 6018, 1], [9460, 6019, 1], [9460, 6020, 1], [9460, 6021, 1], [9460, 6022, 1], [9460, 6023, 1], [9460, 6024, 1], [9460, 6025, 1], [9460, 6026, 1], [9460, 6027, 1], [9460, 6028, 1], [9460, 6029, 1], [9460, 6030, 1], [9460, 6031, 1], [9460, 6032, 1], [9460, 6033, 1], [9460, 6034, 1], [9460, 6035, 1], [9460, 6036, 1], [9460, 6037, 1], [9460, 6038, 1], [9460, 6039, 1], [9460, 6040, 1], [9460, 6041, 1], [9460, 6042, 1], [9460, 6043, 1], [9460, 6044, 1], [9460, 6045, 1], [9460, 6046, 1], [9460, 6047, 1], [9460, 6048, 1], [9460, 6049, 1], [9460, 6050, 1], [9460, 6051, 1], [9460, 6052, 1], [9460, 6053, 1], [9460, 6054, 1], [9460, 6055, 1], [9460, 6056, 1], [9460, 6057, 1], [9460, 6058, 1], [9460, 6059, 1], [9460, 6060, 1], [9460, 6061, 1], [9460, 6062, 1], [9460, 6063, 1], [9460, 6064, 1], [9460, 6065, 1], [9460, 6066, 1], [9460, 6067, 1], [9460, 6068, 1], [9460, 6069, 1], [9460, 6070, 1], [9460, 6071, 1], [9460, 6072, 1], [9460, 6073, 1], [9460, 6074, 1], [9460, 6075, 1], [9460, 6076, 1], [9460, 6077, 1], [9460, 6078, 1], [9460, 6079, 1], [9460, 6080, 1], [9460, 6081, 1], [9460, 6082, 1], [9460, 6083, 1], [922, 923, 1], [9457, 928, 1], [9457, 7764, 1], [9457, 7765, 1], [9457, 7766, 1], [9457, 7767, 1], [9457, 7768, 1], [9457, 7769, 1], [9457, 7770, 1], [9457, 7771, 1], [9457, 7772, 1], [9457, 7773, 1], [9457, 7774, 1], [9457, 7775, 1], [9457, 7776, 1], [9457, 7777, 1], [9457, 7778, 1], [9457, 7779, 1], [9457, 7780, 1], [9457, 7781, 1], [9457, 7782, 1], [9457, 7783, 1], [9457, 7784, 1], [9457, 7785, 1], [9457, 7786, 1], [9457, 7787, 1], [9457, 7788, 1], [9457, 7789, 1], [9457, 7790, 1], [9457, 7791, 1], [9457, 7792, 1], [9457, 7793, 1], [9457, 7794, 1], [9457, 7795, 1], [9457, 7796, 1], [9457, 7797, 1], [9457, 7798, 1], [9457, 7799, 1], [9457, 7800, 1], [9457, 7801, 1], [9457, 7802, 1], [9457, 7803, 1], [9457, 7804, 1], [9457, 7805, 1], [9457, 7806, 1], [9457, 7807, 1], [9457, 7808, 1], [9457, 7809, 1], [9457, 7810, 1], [9457, 7811, 1], [9457, 7812, 1], [9457, 7813, 1], [9457, 7814, 1], [9457, 7815, 1], [9457, 7816, 1], [9457, 7817, 1], [9457, 7818, 1], [9457, 7819, 1], [9457, 7820, 1], [9457, 7821, 1], [9457, 7822, 1], [9457, 7823, 1], [9457, 7824, 1], [9457, 7825, 1], [9457, 7826, 1], [9457, 7827, 1], [9457, 7828, 1], [9457, 7829, 1], [9457, 7830, 1], [9457, 7831, 1], [9457, 7832, 1], [9457, 7833, 1], [9457, 7834, 1], [9457, 7835, 1], [9457, 7836, 1], [9457, 7837, 1], [9457, 7838, 1], [9457, 7839, 1], [9457, 7840, 1], [9457, 7841, 1], [9457, 7842, 1], [9457, 7843, 1], [9457, 7844, 1], [9457, 7845, 1], [9457, 7846, 1], [9457, 7847, 1], [9457, 7848, 1], [9457, 7849, 1], [9457, 7850, 1], [9457, 7851, 1], [9457, 7852, 1], [9457, 7853, 1], [9457, 7854, 1], [9457, 7855, 1], [9457, 7856, 1], [9457, 7857, 1], [9457, 7858, 1], [9457, 7859, 1], [9457, 7860, 1], [9457, 7861, 1], [9457, 7862, 1], [9457, 7863, 1], [9457, 7864, 1], [9457, 7865, 1], [9457, 7866, 1], [9457, 7867, 1], [9457, 7868, 1], [9457, 7869, 1], [9457, 7870, 1], [9457, 7871, 1], [9457, 7872, 1], [9457, 7873, 1], [9457, 7874, 1], [9457, 7875, 1], [9457, 7876, 1], [9457, 7877, 1], [9457, 7878, 1], [9457, 7879, 1], [9457, 7880, 1], [9457, 7881, 1], [9457, 7882, 1], [9457, 7883, 1], [9457, 7884, 1], [9457, 7885, 1], [9457, 7886, 1], [9457, 7887, 1], [9457, 7888, 1], [9457, 7889, 1], [9457, 7890, 1], [9457, 7891, 1], [9457, 7892, 1], [9457, 7893, 1], [9457, 7894, 1], [9457, 7895, 1], [9457, 7896, 1], [9457, 7897, 1], [9457, 7898, 1], [9457, 7899, 1], [9457, 7900, 1], [9457, 7901, 1], [9457, 7902, 1], [9457, 7903, 1], [9457, 8464, 1], [9457, 8465, 1], [9457, 8466, 1], [9457, 8467, 1], [9457, 8468, 1], [9457, 8469, 1], [9457, 8470, 1], [9457, 8471, 1], [9457, 8472, 1], [9457, 8473, 1], [9457, 8474, 1], [9457, 8475, 1], [9457, 8476, 1], [9457, 8477, 1], [9457, 8478, 1], [9457, 8479, 1], [9457, 8480, 1], [9457, 8481, 1], [9457, 8482, 1], [9457, 8483, 1], [9457, 8484, 1], [9457, 8485, 1], [9457, 8486, 1], [9457, 8487, 1], [9457, 8488, 1], [9457, 8489, 1], [9457, 8490, 1], [9457, 8491, 1], [9457, 8492, 1], [9457, 8493, 1], [9457, 8494, 1], [9457, 8495, 1], [9457, 8496, 1], [9457, 8497, 1], [9457, 8498, 1], [9457, 8499, 1], [9457, 8500, 1], [9457, 8501, 1], [9457, 8502, 1], [9457, 8503, 1], [9457, 8504, 1], [9457, 8505, 1], [9457, 8506, 1], [9457, 8507, 1], [9457, 8508, 1], [9457, 8509, 1], [9457, 8510, 1], [9457, 8511, 1], [9457, 8512, 1], [9457, 8513, 1], [9457, 8514, 1], [9457, 8515, 1], [9457, 8516, 1], [9457, 8517, 1], [9457, 8518, 1], [9457, 8519, 1], [9457, 8520, 1], [9457, 8521, 1], [9457, 8522, 1], [9457, 8523, 1], [9457, 8524, 1], [9457, 8525, 1], [9457, 8526, 1], [9457, 8527, 1], [9457, 8528, 1], [9457, 8529, 1], [9457, 8530, 1], [9457, 8531, 1], [9457, 8532, 1], [9457, 8533, 1], [9457, 8534, 1], [9457, 8535, 1], [9457, 8536, 1], [9457, 8537, 1], [9457, 8538, 1], [9457, 8539, 1], [9457, 8540, 1], [9457, 8541, 1], [9457, 8542, 1], [9457, 8543, 1], [9457, 8544, 1], [9457, 8545, 1], [9457, 8546, 1], [9457, 8547, 1], [9457, 8548, 1], [9457, 8549, 1], [9457, 8550, 1], [9457, 8551, 1], [9457, 8552, 1], [9457, 8553, 1], [9457, 8554, 1], [9457, 8555, 1], [9457, 8556, 1], [9457, 8557, 1], [9457, 8558, 1], [9457, 8559, 1], [9457, 8560, 1], [9457, 8561, 1], [9457, 8562, 1], [9457, 8563, 1], [9457, 8564, 1], [9457, 8565, 1], [9457, 8566, 1], [9457, 8567, 1], [9457, 8568, 1], [9457, 8569, 1], [9457, 8570, 1], [9457, 8571, 1], [9457, 8572, 1], [9457, 8573, 1], [9457, 8574, 1], [9457, 8575, 1], [9457, 8576, 1], [9457, 8577, 1], [9457, 8578, 1], [9457, 8579, 1], [9457, 8580, 1], [9457, 8581, 1], [9457, 8582, 1], [9457, 8583, 1], [9457, 8584, 1], [9457, 8585, 1], [9457, 8586, 1], [9457, 8587, 1], [9457, 8588, 1], [9457, 8589, 1], [9457, 8590, 1], [9457, 8591, 1], [9457, 8592, 1], [9457, 8593, 1], [9457, 8594, 1], [9457, 8595, 1], [9457, 8596, 1], [9457, 8597, 1], [9457, 8598, 1], [9457, 8599, 1], [9457, 8600, 1], [9457, 8601, 1], [9457, 8602, 1], [9457, 8603, 1], [928, 929, 1], [449, 886, 1], [449, 794, 1], [886, 887, 1], [929, 1034, 1], [973, 9458, 1], [9458, 920, 1], [9458, 4404, 1], [9458, 4405, 1], [9458, 4406, 1], [9458, 4407, 1], [9458, 4408, 1], [9458, 4409, 1], [9458, 4410, 1], [9458, 4411, 1], [9458, 4412, 1], [9458, 4413, 1], [9458, 4414, 1], [9458, 4415, 1], [9458, 4416, 1], [9458, 4417, 1], [9458, 4418, 1], [9458, 4419, 1], [9458, 4420, 1], [9458, 4421, 1], [9458, 4422, 1], [9458, 4423, 1], [9458, 4424, 1], [9458, 4425, 1], [9458, 4426, 1], [9458, 4427, 1], [9458, 4428, 1], [9458, 4429, 1], [9458, 4430, 1], [9458, 4431, 1], [9458, 4432, 1], [9458, 4433, 1], [9458, 4434, 1], [9458, 4435, 1], [9458, 4436, 1], [9458, 4437, 1], [9458, 4438, 1], [9458, 4439, 1], [9458, 4440, 1], [9458, 4441, 1], [9458, 4442, 1], [9458, 4443, 1], [9458, 4444, 1], [9458, 4445, 1], [9458, 4446, 1], [9458, 4447, 1], [9458, 4448, 1], [9458, 4449, 1], [9458, 4450, 1], [9458, 4451, 1], [9458, 4452, 1], [9458, 4453, 1], [9458, 4454, 1], [9458, 4455, 1], [9458, 4456, 1], [9458, 4457, 1], [9458, 4458, 1], [9458, 4459, 1], [9458, 4460, 1], [9458, 4461, 1], [9458, 4462, 1], [9458, 4463, 1], [9458, 4464, 1], [9458, 4465, 1], [9458, 4466, 1], [9458, 4467, 1], [9458, 4468, 1], [9458, 4469, 1], [9458, 4470, 1], [9458, 4471, 1], [9458, 4472, 1], [9458, 4473, 1], [9458, 4474, 1], [9458, 4475, 1], [9458, 4476, 1], [9458, 4477, 1], [9458, 4478, 1], [9458, 4479, 1], [9458, 4480, 1], [9458, 4481, 1], [9458, 4482, 1], [9458, 4483, 1], [9458, 4484, 1], [9458, 4485, 1], [9458, 4486, 1], [9458, 4487, 1], [9458, 4488, 1], [9458, 4489, 1], [9458, 4490, 1], [9458, 4491, 1], [9458, 4492, 1], [9458, 4493, 1], [9458, 4494, 1], [9458, 4495, 1], [9458, 4496, 1], [9458, 4497, 1], [9458, 4498, 1], [9458, 4499, 1], [9458, 4500, 1], [9458, 4501, 1], [9458, 4502, 1], [9458, 4503, 1], [9458, 4504, 1], [9458, 4505, 1], [9458, 4506, 1], [9458, 4507, 1], [9458, 4508, 1], [9458, 4509, 1], [9458, 4510, 1], [9458, 4511, 1], [9458, 4512, 1], [9458, 4513, 1], [9458, 4514, 1], [9458, 4515, 1], [9458, 4516, 1], [9458, 4517, 1], [9458, 4518, 1], [9458, 4519, 1], [9458, 4520, 1], [9458, 4521, 1], [9458, 4522, 1], [9458, 4523, 1], [9458, 4524, 1], [9458, 4525, 1], [9458, 4526, 1], [9458, 4527, 1], [9458, 4528, 1], [9458, 4529, 1], [9458, 4530, 1], [9458, 4531, 1], [9458, 4532, 1], [9458, 4533, 1], [9458, 4534, 1], [9458, 4535, 1], [9458, 4536, 1], [9458, 4537, 1], [9458, 4538, 1], [9458, 4539, 1], [9458, 4540, 1], [9458, 4541, 1], [9458, 4542, 1], [9458, 4543, 1], [9458, 5104, 1], [9458, 5105, 1], [9458, 5106, 1], [9458, 5107, 1], [9458, 5108, 1], [9458, 5109, 1], [9458, 5110, 1], [9458, 5111, 1], [9458, 5112, 1], [9458, 5113, 1], [9458, 5114, 1], [9458, 5115, 1], [9458, 5116, 1], [9458, 5117, 1], [9458, 5118, 1], [9458, 5119, 1], [9458, 5120, 1], [9458, 5121, 1], [9458, 5122, 1], [9458, 5123, 1], [9458, 5124, 1], [9458, 5125, 1], [9458, 5126, 1], [9458, 5127, 1], [9458, 5128, 1], [9458, 5129, 1], [9458, 5130, 1], [9458, 5131, 1], [9458, 5132, 1], [9458, 5133, 1], [9458, 5134, 1], [9458, 5135, 1], [9458, 5136, 1], [9458, 5137, 1], [9458, 5138, 1], [9458, 5139, 1], [9458, 5140, 1], [9458, 5141, 1], [9458, 5142, 1], [9458, 5143, 1], [9458, 5144, 1], [9458, 5145, 1], [9458, 5146, 1], [9458, 5147, 1], [9458, 5148, 1], [9458, 5149, 1], [9458, 5150, 1], [9458, 5151, 1], [9458, 5152, 1], [9458, 5153, 1], [9458, 5154, 1], [9458, 5155, 1], [9458, 5156, 1], [9458, 5157, 1], [9458, 5158, 1], [9458, 5159, 1], [9458, 5160, 1], [9458, 5161, 1], [9458, 5162, 1], [9458, 5163, 1], [9458, 5164, 1], [9458, 5165, 1], [9458, 5166, 1], [9458, 5167, 1], [9458, 5168, 1], [9458, 5169, 1], [9458, 5170, 1], [9458, 5171, 1], [9458, 5172, 1], [9458, 5173, 1], [9458, 5174, 1], [9458, 5175, 1], [9458, 5176, 1], [9458, 5177, 1], [9458, 5178, 1], [9458, 5179, 1], [9458, 5180, 1], [9458, 5181, 1], [9458, 5182, 1], [9458, 5183, 1], [9458, 5184, 1], [9458, 5185, 1], [9458, 5186, 1], [9458, 5187, 1], [9458, 5188, 1], [9458, 5189, 1], [9458, 5190, 1], [9458, 5191, 1], [9458, 5192, 1], [9458, 5193, 1], [9458, 5194, 1], [9458, 5195, 1], [9458, 5196, 1], [9458, 5197, 1], [9458, 5198, 1], [9458, 5199, 1], [9458, 5200, 1], [9458, 5201, 1], [9458, 5202, 1], [9458, 5203, 1], [9458, 5204, 1], [9458, 5205, 1], [9458, 5206, 1], [9458, 5207, 1], [9458, 5208, 1], [9458, 5209, 1], [9458, 5210, 1], [9458, 5211, 1], [9458, 5212, 1], [9458, 5213, 1], [9458, 5214, 1], [9458, 5215, 1], [9458, 5216, 1], [9458, 5217, 1], [9458, 5218, 1], [9458, 5219, 1], [9458, 5220, 1], [9458, 5221, 1], [9458, 5222, 1], [9458, 5223, 1], [9458, 5224, 1], [9458, 5225, 1], [9458, 5226, 1], [9458, 5227, 1], [9458, 5228, 1], [9458, 5229, 1], [9458, 5230, 1], [9458, 5231, 1], [9458, 5232, 1], [9458, 5233, 1], [9458, 5234, 1], [9458, 5235, 1], [9458, 5236, 1], [9458, 5237, 1], [9458, 5238, 1], [9458, 5239, 1], [9458, 5240, 1], [9458, 5241, 1], [9458, 5242, 1], [9458, 5243, 1], [1017, 1036, 1], [971, 9448, 1], [9448, 1006, 1], [9448, 5384, 1], [9448, 5385, 1], [9448, 5386, 1], [9448, 5387, 1], [9448, 5388, 1], [9448, 5389, 1], [9448, 5390, 1], [9448, 5391, 1], [9448, 5392, 1], [9448, 5393, 1], [9448, 5394, 1], [9448, 5395, 1], [9448, 5396, 1], [9448, 5397, 1], [9448, 5398, 1], [9448, 5399, 1], [9448, 5400, 1], [9448, 5401, 1], [9448, 5402, 1], [9448, 5403, 1], [9448, 5404, 1], [9448, 5405, 1], [9448, 5406, 1], [9448, 5407, 1], [9448, 5408, 1], [9448, 5409, 1], [9448, 5410, 1], [9448, 5411, 1], [9448, 5412, 1], [9448, 5413, 1], [9448, 5414, 1], [9448, 5415, 1], [9448, 5416, 1], [9448, 5417, 1], [9448, 5418, 1], [9448, 5419, 1], [9448, 5420, 1], [9448, 5421, 1], [9448, 5422, 1], [9448, 5423, 1], [9448, 5424, 1], [9448, 5425, 1], [9448, 5426, 1], [9448, 5427, 1], [9448, 5428, 1], [9448, 5429, 1], [9448, 5430, 1], [9448, 5431, 1], [9448, 5432, 1], [9448, 5433, 1], [9448, 5434, 1], [9448, 5435, 1], [9448, 5436, 1], [9448, 5437, 1], [9448, 5438, 1], [9448, 5439, 1], [9448, 5440, 1], [9448, 5441, 1], [9448, 5442, 1], [9448, 5443, 1], [9448, 5444, 1], [9448, 5445, 1], [9448, 5446, 1], [9448, 5447, 1], [9448, 5448, 1], [9448, 5449, 1], [9448, 5450, 1], [9448, 5451, 1], [9448, 5452, 1], [9448, 5453, 1], [9448, 5454, 1], [9448, 5455, 1], [9448, 5456, 1], [9448, 5457, 1], [9448, 5458, 1], [9448, 5459, 1], [9448, 5460, 1], [9448, 5461, 1], [9448, 5462, 1], [9448, 5463, 1], [9448, 5464, 1], [9448, 5465, 1], [9448, 5466, 1], [9448, 5467, 1], [9448, 5468, 1], [9448, 5469, 1], [9448, 5470, 1], [9448, 5471, 1], [9448, 5472, 1], [9448, 5473, 1], [9448, 5474, 1], [9448, 5475, 1], [9448, 5476, 1], [9448, 5477, 1], [9448, 5478, 1], [9448, 5479, 1], [9448, 5480, 1], [9448, 5481, 1], [9448, 5482, 1], [9448, 5483, 1], [9448, 5484, 1], [9448, 5485, 1], [9448, 5486, 1], [9448, 5487, 1], [9448, 5488, 1], [9448, 5489, 1], [9448, 5490, 1], [9448, 5491, 1], [9448, 5492, 1], [9448, 5493, 1], [9448, 5494, 1], [9448, 5495, 1], [9448, 5496, 1], [9448, 5497, 1], [9448, 5498, 1], [9448, 5499, 1], [9448, 5500, 1], [9448, 5501, 1], [9448, 5502, 1], [9448, 5503, 1], [9448, 5504, 1], [9448, 5505, 1], [9448, 5506, 1], [9448, 5507, 1], [9448, 5508, 1], [9448, 5509, 1], [9448, 5510, 1], [9448, 5511, 1], [9448, 5512, 1], [9448, 5513, 1], [9448, 5514, 1], [9448, 5515, 1], [9448, 5516, 1], [9448, 5517, 1], [9448, 5518, 1], [9448, 5519, 1], [9448, 5520, 1], [9448, 5521, 1], [9448, 5522, 1], [9448, 5523, 1], [9448, 5804, 1], [9448, 5805, 1], [9448, 5806, 1], [9448, 5807, 1], [9448, 5808, 1], [9448, 5809, 1], [9448, 5810, 1], [9448, 5811, 1], [9448, 5812, 1], [9448, 5813, 1], [9448, 5814, 1], [9448, 5815, 1], [9448, 5816, 1], [9448, 5817, 1], [9448, 5818, 1], [9448, 5819, 1], [9448, 5820, 1], [9448, 5821, 1], [9448, 5822, 1], [9448, 5823, 1], [9448, 5824, 1], [9448, 5825, 1], [9448, 5826, 1], [9448, 5827, 1], [9448, 5828, 1], [9448, 5829, 1], [9448, 5830, 1], [9448, 5831, 1], [9448, 5832, 1], [9448, 5833, 1], [9448, 5834, 1], [9448, 5835, 1], [9448, 5836, 1], [9448, 5837, 1], [9448, 5838, 1], [9448, 5839, 1], [9448, 5840, 1], [9448, 5841, 1], [9448, 5842, 1], [9448, 5843, 1], [9448, 5844, 1], [9448, 5845, 1], [9448, 5846, 1], [9448, 5847, 1], [9448, 5848, 1], [9448, 5849, 1], [9448, 5850, 1], [9448, 5851, 1], [9448, 5852, 1], [9448, 5853, 1], [9448, 5854, 1], [9448, 5855, 1], [9448, 5856, 1], [9448, 5857, 1], [9448, 5858, 1], [9448, 5859, 1], [9448, 5860, 1], [9448, 5861, 1], [9448, 5862, 1], [9448, 5863, 1], [9448, 5864, 1], [9448, 5865, 1], [9448, 5866, 1], [9448, 5867, 1], [9448, 5868, 1], [9448, 5869, 1], [9448, 5870, 1], [9448, 5871, 1], [9448, 5872, 1], [9448, 5873, 1], [9448, 5874, 1], [9448, 5875, 1], [9448, 5876, 1], [9448, 5877, 1], [9448, 5878, 1], [9448, 5879, 1], [9448, 5880, 1], [9448, 5881, 1], [9448, 5882, 1], [9448, 5883, 1], [9448, 5884, 1], [9448, 5885, 1], [9448, 5886, 1], [9448, 5887, 1], [9448, 5888, 1], [9448, 5889, 1], [9448, 5890, 1], [9448, 5891, 1], [9448, 5892, 1], [9448, 5893, 1], [9448, 5894, 1], [9448, 5895, 1], [9448, 5896, 1], [9448, 5897, 1], [9448, 5898, 1], [9448, 5899, 1], [9448, 5900, 1], [9448, 5901, 1], [9448, 5902, 1], [9448, 5903, 1], [9448, 5904, 1], [9448, 5905, 1], [9448, 5906, 1], [9448, 5907, 1], [9448, 5908, 1], [9448, 5909, 1], [9448, 5910, 1], [9448, 5911, 1], [9448, 5912, 1], [9448, 5913, 1], [9448, 5914, 1], [9448, 5915, 1], [9448, 5916, 1], [9448, 5917, 1], [9448, 5918, 1], [9448, 5919, 1], [9448, 5920, 1], [9448, 5921, 1], [9448, 5922, 1], [9448, 5923, 1], [9448, 5924, 1], [9448, 5925, 1], [9448, 5926, 1], [9448, 5927, 1], [9448, 5928, 1], [9448, 5929, 1], [9448, 5930, 1], [9448, 5931, 1], [9448, 5932, 1], [9448, 5933, 1], [9448, 5934, 1], [9448, 5935, 1], [9448, 5936, 1], [9448, 5937, 1], [9448, 5938, 1], [9448, 5939, 1], [9448, 5940, 1], [9448, 5941, 1], [9448, 5942, 1], [9448, 5943, 1], [932, 933, 1], [999, 1038, 1], [948, 949, 1], [942, 943, 1], [972, 973, 1], [959, 9445, 1], [9445, 998, 1], [9445, 4544, 1], [9445, 4545, 1], [9445, 4546, 1], [9445, 4547, 1], [9445, 4548, 1], [9445, 4549, 1], [9445, 4550, 1], [9445, 4551, 1], [9445, 4552, 1], [9445, 4553, 1], [9445, 4554, 1], [9445, 4555, 1], [9445, 4556, 1], [9445, 4557, 1], [9445, 4558, 1], [9445, 4559, 1], [9445, 4560, 1], [9445, 4561, 1], [9445, 4562, 1], [9445, 4563, 1], [9445, 4564, 1], [9445, 4565, 1], [9445, 4566, 1], [9445, 4567, 1], [9445, 4568, 1], [9445, 4569, 1], [9445, 4570, 1], [9445, 4571, 1], [9445, 4572, 1], [9445, 4573, 1], [9445, 4574, 1], [9445, 4575, 1], [9445, 4576, 1], [9445, 4577, 1], [9445, 4578, 1], [9445, 4579, 1], [9445, 4580, 1], [9445, 4581, 1], [9445, 4582, 1], [9445, 4583, 1], [9445, 4584, 1], [9445, 4585, 1], [9445, 4586, 1], [9445, 4587, 1], [9445, 4588, 1], [9445, 4589, 1], [9445, 4590, 1], [9445, 4591, 1], [9445, 4592, 1], [9445, 4593, 1], [9445, 4594, 1], [9445, 4595, 1], [9445, 4596, 1], [9445, 4597, 1], [9445, 4598, 1], [9445, 4599, 1], [9445, 4600, 1], [9445, 4601, 1], [9445, 4602, 1], [9445, 4603, 1], [9445, 4604, 1], [9445, 4605, 1], [9445, 4606, 1], [9445, 4607, 1], [9445, 4608, 1], [9445, 4609, 1], [9445, 4610, 1], [9445, 4611, 1], [9445, 4612, 1], [9445, 4613, 1], [9445, 4614, 1], [9445, 4615, 1], [9445, 4616, 1], [9445, 4617, 1], [9445, 4618, 1], [9445, 4619, 1], [9445, 4620, 1], [9445, 4621, 1], [9445, 4622, 1], [9445, 4623, 1], [9445, 4624, 1], [9445, 4625, 1], [9445, 4626, 1], [9445, 4627, 1], [9445, 4628, 1], [9445, 4629, 1], [9445, 4630, 1], [9445, 4631, 1], [9445, 4632, 1], [9445, 4633, 1], [9445, 4634, 1], [9445, 4635, 1], [9445, 4636, 1], [9445, 4637, 1], [9445, 4638, 1], [9445, 4639, 1], [9445, 4640, 1], [9445, 4641, 1], [9445, 4642, 1], [9445, 4643, 1], [9445, 4644, 1], [9445, 4645, 1], [9445, 4646, 1], [9445, 4647, 1], [9445, 4648, 1], [9445, 4649, 1], [9445, 4650, 1], [9445, 4651, 1], [9445, 4652, 1], [9445, 4653, 1], [9445, 4654, 1], [9445, 4655, 1], [9445, 4656, 1], [9445, 4657, 1], [9445, 4658, 1], [9445, 4659, 1], [9445, 4660, 1], [9445, 4661, 1], [9445, 4662, 1], [9445, 4663, 1], [9445, 4664, 1], [9445, 4665, 1], [9445, 4666, 1], [9445, 4667, 1], [9445, 4668, 1], [9445, 4669, 1], [9445, 4670, 1], [9445, 4671, 1], [9445, 4672, 1], [9445, 4673, 1], [9445, 4674, 1], [9445, 4675, 1], [9445, 4676, 1], [9445, 4677, 1], [9445, 4678, 1], [9445, 4679, 1], [9445, 4680, 1], [9445, 4681, 1], [9445, 4682, 1], [9445, 4683, 1], [9445, 4964, 1], [9445, 4965, 1], [9445, 4966, 1], [9445, 4967, 1], [9445, 4968, 1], [9445, 4969, 1], [9445, 4970, 1], [9445, 4971, 1], [9445, 4972, 1], [9445, 4973, 1], [9445, 4974, 1], [9445, 4975, 1], [9445, 4976, 1], [9445, 4977, 1], [9445, 4978, 1], [9445, 4979, 1], [9445, 4980, 1], [9445, 4981, 1], [9445, 4982, 1], [9445, 4983, 1], [9445, 4984, 1], [9445, 4985, 1], [9445, 4986, 1], [9445, 4987, 1], [9445, 4988, 1], [9445, 4989, 1], [9445, 4990, 1], [9445, 4991, 1], [9445, 4992, 1], [9445, 4993, 1], [9445, 4994, 1], [9445, 4995, 1], [9445, 4996, 1], [9445, 4997, 1], [9445, 4998, 1], [9445, 4999, 1], [9445, 5000, 1], [9445, 5001, 1], [9445, 5002, 1], [9445, 5003, 1], [9445, 5004, 1], [9445, 5005, 1], [9445, 5006, 1], [9445, 5007, 1], [9445, 5008, 1], [9445, 5009, 1], [9445, 5010, 1], [9445, 5011, 1], [9445, 5012, 1], [9445, 5013, 1], [9445, 5014, 1], [9445, 5015, 1], [9445, 5016, 1], [9445, 5017, 1], [9445, 5018, 1], [9445, 5019, 1], [9445, 5020, 1], [9445, 5021, 1], [9445, 5022, 1], [9445, 5023, 1], [9445, 5024, 1], [9445, 5025, 1], [9445, 5026, 1], [9445, 5027, 1], [9445, 5028, 1], [9445, 5029, 1], [9445, 5030, 1], [9445, 5031, 1], [9445, 5032, 1], [9445, 5033, 1], [9445, 5034, 1], [9445, 5035, 1], [9445, 5036, 1], [9445, 5037, 1], [9445, 5038, 1], [9445, 5039, 1], [9445, 5040, 1], [9445, 5041, 1], [9445, 5042, 1], [9445, 5043, 1], [9445, 5044, 1], [9445, 5045, 1], [9445, 5046, 1], [9445, 5047, 1], [9445, 5048, 1], [9445, 5049, 1], [9445, 5050, 1], [9445, 5051, 1], [9445, 5052, 1], [9445, 5053, 1], [9445, 5054, 1], [9445, 5055, 1], [9445, 5056, 1], [9445, 5057, 1], [9445, 5058, 1], [9445, 5059, 1], [9445, 5060, 1], [9445, 5061, 1], [9445, 5062, 1], [9445, 5063, 1], [9445, 5064, 1], [9445, 5065, 1], [9445, 5066, 1], [9445, 5067, 1], [9445, 5068, 1], [9445, 5069, 1], [9445, 5070, 1], [9445, 5071, 1], [9445, 5072, 1], [9445, 5073, 1], [9445, 5074, 1], [9445, 5075, 1], [9445, 5076, 1], [9445, 5077, 1], [9445, 5078, 1], [9445, 5079, 1], [9445, 5080, 1], [9445, 5081, 1], [9445, 5082, 1], [9445, 5083, 1], [9445, 5084, 1], [9445, 5085, 1], [9445, 5086, 1], [9445, 5087, 1], [9445, 5088, 1], [9445, 5089, 1], [9445, 5090, 1], [9445, 5091, 1], [9445, 5092, 1], [9445, 5093, 1], [9445, 5094, 1], [9445, 5095, 1], [9445, 5096, 1], [9445, 5097, 1], [9445, 5098, 1], [9445, 5099, 1], [9445, 5100, 1], [9445, 5101, 1], [9445, 5102, 1], [9445, 5103, 1], [240, 322, 1], [322, 323, 1], [237, 723, 1], [723, 724, 1], [9459, 924, 1], [9459, 6084, 1], [9459, 6085, 1], [9459, 6086, 1], [9459, 6087, 1], [9459, 6088, 1], [9459, 6089, 1], [9459, 6090, 1], [9459, 6091, 1], [9459, 6092, 1], [9459, 6093, 1], [9459, 6094, 1], [9459, 6095, 1], [9459, 6096, 1], [9459, 6097, 1], [9459, 6098, 1], [9459, 6099, 1], [9459, 6100, 1], [9459, 6101, 1], [9459, 6102, 1], [9459, 6103, 1], [9459, 6104, 1], [9459, 6105, 1], [9459, 6106, 1], [9459, 6107, 1], [9459, 6108, 1], [9459, 6109, 1], [9459, 6110, 1], [9459, 6111, 1], [9459, 6112, 1], [9459, 6113, 1], [9459, 6114, 1], [9459, 6115, 1], [9459, 6116, 1], [9459, 6117, 1], [9459, 6118, 1], [9459, 6119, 1], [9459, 6120, 1], [9459, 6121, 1], [9459, 6122, 1], [9459, 6123, 1], [9459, 6124, 1], [9459, 6125, 1], [9459, 6126, 1], [9459, 6127, 1], [9459, 6128, 1], [9459, 6129, 1], [9459, 6130, 1], [9459, 6131, 1], [9459, 6132, 1], [9459, 6133, 1], [9459, 6134, 1], [9459, 6135, 1], [9459, 6136, 1], [9459, 6137, 1], [9459, 6138, 1], [9459, 6139, 1], [9459, 6140, 1], [9459, 6141, 1], [9459, 6142, 1], [9459, 6143, 1], [9459, 6144, 1], [9459, 6145, 1], [9459, 6146, 1], [9459, 6147, 1], [9459, 6148, 1], [9459, 6149, 1], [9459, 6150, 1], [9459, 6151, 1], [9459, 6152, 1], [9459, 6153, 1], [9459, 6154, 1], [9459, 6155, 1], [9459, 6156, 1], [9459, 6157, 1], [9459, 6158, 1], [9459, 6159, 1], [9459, 6160, 1], [9459, 6161, 1], [9459, 6162, 1], [9459, 6163, 1], [9459, 6164, 1], [9459, 6165, 1], [9459, 6166, 1], [9459, 6167, 1], [9459, 6168, 1], [9459, 6169, 1], [9459, 6170, 1], [9459, 6171, 1], [9459, 6172, 1], [9459, 6173, 1], [9459, 6174, 1], [9459, 6175, 1], [9459, 6176, 1], [9459, 6177, 1], [9459, 6178, 1], [9459, 6179, 1], [9459, 6180, 1], [9459, 6181, 1], [9459, 6182, 1], [9459, 6183, 1], [9459, 6184, 1], [9459, 6185, 1], [9459, 6186, 1], [9459, 6187, 1], [9459, 6188, 1], [9459, 6189, 1], [9459, 6190, 1], [9459, 6191, 1], [9459, 6192, 1], [9459, 6193, 1], [9459, 6194, 1], [9459, 6195, 1], [9459, 6196, 1], [9459, 6197, 1], [9459, 6198, 1], [9459, 6199, 1], [9459, 6200, 1], [9459, 6201, 1], [9459, 6202, 1], [9459, 6203, 1], [9459, 6204, 1], [9459, 6205, 1], [9459, 6206, 1], [9459, 6207, 1], [9459, 6208, 1], [9459, 6209, 1], [9459, 6210, 1], [9459, 6211, 1], [9459, 6212, 1], [9459, 6213, 1], [9459, 6214, 1], [9459, 6215, 1], [9459, 6216, 1], [9459, 6217, 1], [9459, 6218, 1], [9459, 6219, 1], [9459, 6220, 1], [9459, 6221, 1], [9459, 6222, 1], [9459, 6223, 1], [9459, 6784, 1], [9459, 6785, 1], [9459, 6786, 1], [9459, 6787, 1], [9459, 6788, 1], [9459, 6789, 1], [9459, 6790, 1], [9459, 6791, 1], [9459, 6792, 1], [9459, 6793, 1], [9459, 6794, 1], [9459, 6795, 1], [9459, 6796, 1], [9459, 6797, 1], [9459, 6798, 1], [9459, 6799, 1], [9459, 6800, 1], [9459, 6801, 1], [9459, 6802, 1], [9459, 6803, 1], [9459, 6804, 1], [9459, 6805, 1], [9459, 6806, 1], [9459, 6807, 1], [9459, 6808, 1], [9459, 6809, 1], [9459, 6810, 1], [9459, 6811, 1], [9459, 6812, 1], [9459, 6813, 1], [9459, 6814, 1], [9459, 6815, 1], [9459, 6816, 1], [9459, 6817, 1], [9459, 6818, 1], [9459, 6819, 1], [9459, 6820, 1], [9459, 6821, 1], [9459, 6822, 1], [9459, 6823, 1], [9459, 6824, 1], [9459, 6825, 1], [9459, 6826, 1], [9459, 6827, 1], [9459, 6828, 1], [9459, 6829, 1], [9459, 6830, 1], [9459, 6831, 1], [9459, 6832, 1], [9459, 6833, 1], [9459, 6834, 1], [9459, 6835, 1], [9459, 6836, 1], [9459, 6837, 1], [9459, 6838, 1], [9459, 6839, 1], [9459, 6840, 1], [9459, 6841, 1], [9459, 6842, 1], [9459, 6843, 1], [9459, 6844, 1], [9459, 6845, 1], [9459, 6846, 1], [9459, 6847, 1], [9459, 6848, 1], [9459, 6849, 1], [9459, 6850, 1], [9459, 6851, 1], [9459, 6852, 1], [9459, 6853, 1], [9459, 6854, 1], [9459, 6855, 1], [9459, 6856, 1], [9459, 6857, 1], [9459, 6858, 1], [9459, 6859, 1], [9459, 6860, 1], [9459, 6861, 1], [9459, 6862, 1], [9459, 6863, 1], [9459, 6864, 1], [9459, 6865, 1], [9459, 6866, 1], [9459, 6867, 1], [9459, 6868, 1], [9459, 6869, 1], [9459, 6870, 1], [9459, 6871, 1], [9459, 6872, 1], [9459, 6873, 1], [9459, 6874, 1], [9459, 6875, 1], [9459, 6876, 1], [9459, 6877, 1], [9459, 6878, 1], [9459, 6879, 1], [9459, 6880, 1], [9459, 6881, 1], [9459, 6882, 1], [9459, 6883, 1], [9459, 6884, 1], [9459, 6885, 1], [9459, 6886, 1], [9459, 6887, 1], [9459, 6888, 1], [9459, 6889, 1], [9459, 6890, 1], [9459, 6891, 1], [9459, 6892, 1], [9459, 6893, 1], [9459, 6894, 1], [9459, 6895, 1], [9459, 6896, 1], [9459, 6897, 1], [9459, 6898, 1], [9459, 6899, 1], [9459, 6900, 1], [9459, 6901, 1], [9459, 6902, 1], [9459, 6903, 1], [9459, 6904, 1], [9459, 6905, 1], [9459, 6906, 1], [9459, 6907, 1], [9459, 6908, 1], [9459, 6909, 1], [9459, 6910, 1], [9459, 6911, 1], [9459, 6912, 1], [9459, 6913, 1], [9459, 6914, 1], [9459, 6915, 1], [9459, 6916, 1], [9459, 6917, 1], [9459, 6918, 1], [9459, 6919, 1], [9459, 6920, 1], [9459, 6921, 1], [9459, 6922, 1], [9459, 6923, 1], [924, 925, 1], [49, 128, 1], [128, 129, 1], [364, 412, 1], [412, 390, 1], [412, 698, 1], [913, 1034, 1], [998, 999, 1], [396, 611, 1], [396, 356, 1], [611, 612, 1], [9447, 1004, 1], [9447, 3704, 1], [9447, 3705, 1], [9447, 3706, 1], [9447, 3707, 1], [9447, 3708, 1], [9447, 3709, 1], [9447, 3710, 1], [9447, 3711, 1], [9447, 3712, 1], [9447, 3713, 1], [9447, 3714, 1], [9447, 3715, 1], [9447, 3716, 1], [9447, 3717, 1], [9447, 3718, 1], [9447, 3719, 1], [9447, 3720, 1], [9447, 3721, 1], [9447, 3722, 1], [9447, 3723, 1], [9447, 3724, 1], [9447, 3725, 1], [9447, 3726, 1], [9447, 3727, 1], [9447, 3728, 1], [9447, 3729, 1], [9447, 3730, 1], [9447, 3731, 1], [9447, 3732, 1], [9447, 3733, 1], [9447, 3734, 1], [9447, 3735, 1], [9447, 3736, 1], [9447, 3737, 1], [9447, 3738, 1], [9447, 3739, 1], [9447, 3740, 1], [9447, 3741, 1], [9447, 3742, 1], [9447, 3743, 1], [9447, 3744, 1], [9447, 3745, 1], [9447, 3746, 1], [9447, 3747, 1], [9447, 3748, 1], [9447, 3749, 1], [9447, 3750, 1], [9447, 3751, 1], [9447, 3752, 1], [9447, 3753, 1], [9447, 3754, 1], [9447, 3755, 1], [9447, 3756, 1], [9447, 3757, 1], [9447, 3758, 1], [9447, 3759, 1], [9447, 3760, 1], [9447, 3761, 1], [9447, 3762, 1], [9447, 3763, 1], [9447, 3764, 1], [9447, 3765, 1], [9447, 3766, 1], [9447, 3767, 1], [9447, 3768, 1], [9447, 3769, 1], [9447, 3770, 1], [9447, 3771, 1], [9447, 3772, 1], [9447, 3773, 1], [9447, 3774, 1], [9447, 3775, 1], [9447, 3776, 1], [9447, 3777, 1], [9447, 3778, 1], [9447, 3779, 1], [9447, 3780, 1], [9447, 3781, 1], [9447, 3782, 1], [9447, 3783, 1], [9447, 3784, 1], [9447, 3785, 1], [9447, 3786, 1], [9447, 3787, 1], [9447, 3788, 1], [9447, 3789, 1], [9447, 3790, 1], [9447, 3791, 1], [9447, 3792, 1], [9447, 3793, 1], [9447, 3794, 1], [9447, 3795, 1], [9447, 3796, 1], [9447, 3797, 1], [9447, 3798, 1], [9447, 3799, 1], [9447, 3800, 1], [9447, 3801, 1], [9447, 3802, 1], [9447, 3803, 1], [9447, 3804, 1], [9447, 3805, 1], [9447, 3806, 1], [9447, 3807, 1], [9447, 3808, 1], [9447, 3809, 1], [9447, 3810, 1], [9447, 3811, 1], [9447, 3812, 1], [9447, 3813, 1], [9447, 3814, 1], [9447, 3815, 1], [9447, 3816, 1], [9447, 3817, 1], [9447, 3818, 1], [9447, 3819, 1], [9447, 3820, 1], [9447, 3821, 1], [9447, 3822, 1], [9447, 3823, 1], [9447, 3824, 1], [9447, 3825, 1], [9447, 3826, 1], [9447, 3827, 1], [9447, 3828, 1], [9447, 3829, 1], [9447, 3830, 1], [9447, 3831, 1], [9447, 3832, 1], [9447, 3833, 1], [9447, 3834, 1], [9447, 3835, 1], [9447, 3836, 1], [9447, 3837, 1], [9447, 3838, 1], [9447, 3839, 1], [9447, 3840, 1], [9447, 3841, 1], [9447, 3842, 1], [9447, 3843, 1], [9447, 4124, 1], [9447, 4125, 1], [9447, 4126, 1], [9447, 4127, 1], [9447, 4128, 1], [9447, 4129, 1], [9447, 4130, 1], [9447, 4131, 1], [9447, 4132, 1], [9447, 4133, 1], [9447, 4134, 1], [9447, 4135, 1], [9447, 4136, 1], [9447, 4137, 1], [9447, 4138, 1], [9447, 4139, 1], [9447, 4140, 1], [9447, 4141, 1], [9447, 4142, 1], [9447, 4143, 1], [9447, 4144, 1], [9447, 4145, 1], [9447, 4146, 1], [9447, 4147, 1], [9447, 4148, 1], [9447, 4149, 1], [9447, 4150, 1], [9447, 4151, 1], [9447, 4152, 1], [9447, 4153, 1], [9447, 4154, 1], [9447, 4155, 1], [9447, 4156, 1], [9447, 4157, 1], [9447, 4158, 1], [9447, 4159, 1], [9447, 4160, 1], [9447, 4161, 1], [9447, 4162, 1], [9447, 4163, 1], [9447, 4164, 1], [9447, 4165, 1], [9447, 4166, 1], [9447, 4167, 1], [9447, 4168, 1], [9447, 4169, 1], [9447, 4170, 1], [9447, 4171, 1], [9447, 4172, 1], [9447, 4173, 1], [9447, 4174, 1], [9447, 4175, 1], [9447, 4176, 1], [9447, 4177, 1], [9447, 4178, 1], [9447, 4179, 1], [9447, 4180, 1], [9447, 4181, 1], [9447, 4182, 1], [9447, 4183, 1], [9447, 4184, 1], [9447, 4185, 1], [9447, 4186, 1], [9447, 4187, 1], [9447, 4188, 1], [9447, 4189, 1], [9447, 4190, 1], [9447, 4191, 1], [9447, 4192, 1], [9447, 4193, 1], [9447, 4194, 1], [9447, 4195, 1], [9447, 4196, 1], [9447, 4197, 1], [9447, 4198, 1], [9447, 4199, 1], [9447, 4200, 1], [9447, 4201, 1], [9447, 4202, 1], [9447, 4203, 1], [9447, 4204, 1], [9447, 4205, 1], [9447, 4206, 1], [9447, 4207, 1], [9447, 4208, 1], [9447, 4209, 1], [9447, 4210, 1], [9447, 4211, 1], [9447, 4212, 1], [9447, 4213, 1], [9447, 4214, 1], [9447, 4215, 1], [9447, 4216, 1], [9447, 4217, 1], [9447, 4218, 1], [9447, 4219, 1], [9447, 4220, 1], [9447, 4221, 1], [9447, 4222, 1], [9447, 4223, 1], [9447, 4224, 1], [9447, 4225, 1], [9447, 4226, 1], [9447, 4227, 1], [9447, 4228, 1], [9447, 4229, 1], [9447, 4230, 1], [9447, 4231, 1], [9447, 4232, 1], [9447, 4233, 1], [9447, 4234, 1], [9447, 4235, 1], [9447, 4236, 1], [9447, 4237, 1], [9447, 4238, 1], [9447, 4239, 1], [9447, 4240, 1], [9447, 4241, 1], [9447, 4242, 1], [9447, 4243, 1], [9447, 4244, 1], [9447, 4245, 1], [9447, 4246, 1], [9447, 4247, 1], [9447, 4248, 1], [9447, 4249, 1], [9447, 4250, 1], [9447, 4251, 1], [9447, 4252, 1], [9447, 4253, 1], [9447, 4254, 1], [9447, 4255, 1], [9447, 4256, 1], [9447, 4257, 1], [9447, 4258, 1], [9447, 4259, 1], [9447, 4260, 1], [9447, 4261, 1], [9447, 4262, 1], [9447, 4263, 1], [1004, 1005, 1], [499, 175, 1], [9444, 996, 1], [9444, 1184, 1], [9444, 1185, 1], [9444, 1186, 1], [9444, 1187, 1], [9444, 1188, 1], [9444, 1189, 1], [9444, 1190, 1], [9444, 1191, 1], [9444, 1192, 1], [9444, 1193, 1], [9444, 1194, 1], [9444, 1195, 1], [9444, 1196, 1], [9444, 1197, 1], [9444, 1198, 1], [9444, 1199, 1], [9444, 1200, 1], [9444, 1201, 1], [9444, 1202, 1], [9444, 1203, 1], [9444, 1204, 1], [9444, 1205, 1], [9444, 1206, 1], [9444, 1207, 1], [9444, 1208, 1], [9444, 1209, 1], [9444, 1210, 1], [9444, 1211, 1], [9444, 1212, 1], [9444, 1213, 1], [9444, 1214, 1], [9444, 1215, 1], [9444, 1216, 1], [9444, 1217, 1], [9444, 1218, 1], [9444, 1219, 1], [9444, 1220, 1], [9444, 1221, 1], [9444, 1222, 1], [9444, 1223, 1], [9444, 1224, 1], [9444, 1225, 1], [9444, 1226, 1], [9444, 1227, 1], [9444, 1228, 1], [9444, 1229, 1], [9444, 1230, 1], [9444, 1231, 1], [9444, 1232, 1], [9444, 1233, 1], [9444, 1234, 1], [9444, 1235, 1], [9444, 1236, 1], [9444, 1237, 1], [9444, 1238, 1], [9444, 1239, 1], [9444, 1240, 1], [9444, 1241, 1], [9444, 1242, 1], [9444, 1243, 1], [9444, 1244, 1], [9444, 1245, 1], [9444, 1246, 1], [9444, 1247, 1], [9444, 1248, 1], [9444, 1249, 1], [9444, 1250, 1], [9444, 1251, 1], [9444, 1252, 1], [9444, 1253, 1], [9444, 1254, 1], [9444, 1255, 1], [9444, 1256, 1], [9444, 1257, 1], [9444, 1258, 1], [9444, 1259, 1], [9444, 1260, 1], [9444, 1261, 1], [9444, 1262, 1], [9444, 1263, 1], [9444, 1264, 1], [9444, 1265, 1], [9444, 1266, 1], [9444, 1267, 1], [9444, 1268, 1], [9444, 1269, 1], [9444, 1270, 1], [9444, 1271, 1], [9444, 1272, 1], [9444, 1273, 1], [9444, 1274, 1], [9444, 1275, 1], [9444, 1276, 1], [9444, 1277, 1], [9444, 1278, 1], [9444, 1279, 1], [9444, 1280, 1], [9444, 1281, 1], [9444, 1282, 1], [9444, 1283, 1], [9444, 1284, 1], [9444, 1285, 1], [9444, 1286, 1], [9444, 1287, 1], [9444, 1288, 1], [9444, 1289, 1], [9444, 1290, 1], [9444, 1291, 1], [9444, 1292, 1], [9444, 1293, 1], [9444, 1294, 1], [9444, 1295, 1], [9444, 1296, 1], [9444, 1297, 1], [9444, 1298, 1], [9444, 1299, 1], [9444, 1300, 1], [9444, 1301, 1], [9444, 1302, 1], [9444, 1303, 1], [9444, 1304, 1], [9444, 1305, 1], [9444, 1306, 1], [9444, 1307, 1], [9444, 1308, 1], [9444, 1309, 1], [9444, 1310, 1], [9444, 1311, 1], [9444, 1312, 1], [9444, 1313, 1], [9444, 1314, 1], [9444, 1315, 1], [9444, 1316, 1], [9444, 1317, 1], [9444, 1318, 1], [9444, 1319, 1], [9444, 1320, 1], [9444, 1321, 1], [9444, 1322, 1], [9444, 1323, 1], [9444, 1604, 1], [9444, 1605, 1], [9444, 1606, 1], [9444, 1607, 1], [9444, 1608, 1], [9444, 1609, 1], [9444, 1610, 1], [9444, 1611, 1], [9444, 1612, 1], [9444, 1613, 1], [9444, 1614, 1], [9444, 1615, 1], [9444, 1616, 1], [9444, 1617, 1], [9444, 1618, 1], [9444, 1619, 1], [9444, 1620, 1], [9444, 1621, 1], [9444, 1622, 1], [9444, 1623, 1], [9444, 1624, 1], [9444, 1625, 1], [9444, 1626, 1], [9444, 1627, 1], [9444, 1628, 1], [9444, 1629, 1], [9444, 1630, 1], [9444, 1631, 1], [9444, 1632, 1], [9444, 1633, 1], [9444, 1634, 1], [9444, 1635, 1], [9444, 1636, 1], [9444, 1637, 1], [9444, 1638, 1], [9444, 1639, 1], [9444, 1640, 1], [9444, 1641, 1], [9444, 1642, 1], [9444, 1643, 1], [9444, 1644, 1], [9444, 1645, 1], [9444, 1646, 1], [9444, 1647, 1], [9444, 1648, 1], [9444, 1649, 1], [9444, 1650, 1], [9444, 1651, 1], [9444, 1652, 1], [9444, 1653, 1], [9444, 1654, 1], [9444, 1655, 1], [9444, 1656, 1], [9444, 1657, 1], [9444, 1658, 1], [9444, 1659, 1], [9444, 1660, 1], [9444, 1661, 1], [9444, 1662, 1], [9444, 1663, 1], [9444, 1664, 1], [9444, 1665, 1], [9444, 1666, 1], [9444, 1667, 1], [9444, 1668, 1], [9444, 1669, 1], [9444, 1670, 1], [9444, 1671, 1], [9444, 1672, 1], [9444, 1673, 1], [9444, 1674, 1], [9444, 1675, 1], [9444, 1676, 1], [9444, 1677, 1], [9444, 1678, 1], [9444, 1679, 1], [9444, 1680, 1], [9444, 1681, 1], [9444, 1682, 1], [9444, 1683, 1], [9444, 1684, 1], [9444, 1685, 1], [9444, 1686, 1], [9444, 1687, 1], [9444, 1688, 1], [9444, 1689, 1], [9444, 1690, 1], [9444, 1691, 1], [9444, 1692, 1], [9444, 1693, 1], [9444, 1694, 1], [9444, 1695, 1], [9444, 1696, 1], [9444, 1697, 1], [9444, 1698, 1], [9444, 1699, 1], [9444, 1700, 1], [9444, 1701, 1], [9444, 1702, 1], [9444, 1703, 1], [9444, 1704, 1], [9444, 1705, 1], [9444, 1706, 1], [9444, 1707, 1], [9444, 1708, 1], [9444, 1709, 1], [9444, 1710, 1], [9444, 1711, 1], [9444, 1712, 1], [9444, 1713, 1], [9444, 1714, 1], [9444, 1715, 1], [9444, 1716, 1], [9444, 1717, 1], [9444, 1718, 1], [9444, 1719, 1], [9444, 1720, 1], [9444, 1721, 1], [9444, 1722, 1], [9444, 1723, 1], [9444, 1724, 1], [9444, 1725, 1], [9444, 1726, 1], [9444, 1727, 1], [9444, 1728, 1], [9444, 1729, 1], [9444, 1730, 1], [9444, 1731, 1], [9444, 1732, 1], [9444, 1733, 1], [9444, 1734, 1], [9444, 1735, 1], [9444, 1736, 1], [9444, 1737, 1], [9444, 1738, 1], [9444, 1739, 1], [9444, 1740, 1], [9444, 1741, 1], [9444, 1742, 1], [9444, 1743, 1], [996, 997, 1], [976, 977, 1], [940, 941, 1], [957, 9444, 1], [950, 951, 1], [1015, 1036, 1], [949, 9468, 1], [9468, 1018, 1], [9468, 1324, 1], [9468, 1325, 1], [9468, 1326, 1], [9468, 1327, 1], [9468, 1328, 1], [9468, 1329, 1], [9468, 1330, 1], [9468, 1331, 1], [9468, 1332, 1], [9468, 1333, 1], [9468, 1334, 1], [9468, 1335, 1], [9468, 1336, 1], [9468, 1337, 1], [9468, 1338, 1], [9468, 1339, 1], [9468, 1340, 1], [9468, 1341, 1], [9468, 1342, 1], [9468, 1343, 1], [9468, 1344, 1], [9468, 1345, 1], [9468, 1346, 1], [9468, 1347, 1], [9468, 1348, 1], [9468, 1349, 1], [9468, 1350, 1], [9468, 1351, 1], [9468, 1352, 1], [9468, 1353, 1], [9468, 1354, 1], [9468, 1355, 1], [9468, 1356, 1], [9468, 1357, 1], [9468, 1358, 1], [9468, 1359, 1], [9468, 1360, 1], [9468, 1361, 1], [9468, 1362, 1], [9468, 1363, 1], [9468, 1364, 1], [9468, 1365, 1], [9468, 1366, 1], [9468, 1367, 1], [9468, 1368, 1], [9468, 1369, 1], [9468, 1370, 1], [9468, 1371, 1], [9468, 1372, 1], [9468, 1373, 1], [9468, 1374, 1], [9468, 1375, 1], [9468, 1376, 1], [9468, 1377, 1], [9468, 1378, 1], [9468, 1379, 1], [9468, 1380, 1], [9468, 1381, 1], [9468, 1382, 1], [9468, 1383, 1], [9468, 1384, 1], [9468, 1385, 1], [9468, 1386, 1], [9468, 1387, 1], [9468, 1388, 1], [9468, 1389, 1], [9468, 1390, 1], [9468, 1391, 1], [9468, 1392, 1], [9468, 1393, 1], [9468, 1394, 1], [9468, 1395, 1], [9468, 1396, 1], [9468, 1397, 1], [9468, 1398, 1], [9468, 1399, 1], [9468, 1400, 1], [9468, 1401, 1], [9468, 1402, 1], [9468, 1403, 1], [9468, 1404, 1], [9468, 1405, 1], [9468, 1406, 1], [9468, 1407, 1], [9468, 1408, 1], [9468, 1409, 1], [9468, 1410, 1], [9468, 1411, 1], [9468, 1412, 1], [9468, 1413, 1], [9468, 1414, 1], [9468, 1415, 1], [9468, 1416, 1], [9468, 1417, 1], [9468, 1418, 1], [9468, 1419, 1], [9468, 1420, 1], [9468, 1421, 1], [9468, 1422, 1], [9468, 1423, 1], [9468, 1424, 1], [9468, 1425, 1], [9468, 1426, 1], [9468, 1427, 1], [9468, 1428, 1], [9468, 1429, 1], [9468, 1430, 1], [9468, 1431, 1], [9468, 1432, 1], [9468, 1433, 1], [9468, 1434, 1], [9468, 1435, 1], [9468, 1436, 1], [9468, 1437, 1], [9468, 1438, 1], [9468, 1439, 1], [9468, 1440, 1], [9468, 1441, 1], [9468, 1442, 1], [9468, 1443, 1], [9468, 1444, 1], [9468, 1445, 1], [9468, 1446, 1], [9468, 1447, 1], [9468, 1448, 1], [9468, 1449, 1], [9468, 1450, 1], [9468, 1451, 1], [9468, 1452, 1], [9468, 1453, 1], [9468, 1454, 1], [9468, 1455, 1], [9468, 1456, 1], [9468, 1457, 1], [9468, 1458, 1], [9468, 1459, 1], [9468, 1460, 1], [9468, 1461, 1], [9468, 1462, 1], [9468, 1463, 1], [9468, 1464, 1], [9468, 1465, 1], [9468, 1466, 1], [9468, 1467, 1], [9468, 1468, 1], [9468, 1469, 1], [9468, 1470, 1], [9468, 1471, 1], [9468, 1472, 1], [9468, 1473, 1], [9468, 1474, 1], [9468, 1475, 1], [9468, 1476, 1], [9468, 1477, 1], [9468, 1478, 1], [9468, 1479, 1], [9468, 1480, 1], [9468, 1481, 1], [9468, 1482, 1], [9468, 1483, 1], [9468, 1484, 1], [9468, 1485, 1], [9468, 1486, 1], [9468, 1487, 1], [9468, 1488, 1], [9468, 1489, 1], [9468, 1490, 1], [9468, 1491, 1], [9468, 1492, 1], [9468, 1493, 1], [9468, 1494, 1], [9468, 1495, 1], [9468, 1496, 1], [9468, 1497, 1], [9468, 1498, 1], [9468, 1499, 1], [9468, 1500, 1], [9468, 1501, 1], [9468, 1502, 1], [9468, 1503, 1], [9468, 1504, 1], [9468, 1505, 1], [9468, 1506, 1], [9468, 1507, 1], [9468, 1508, 1], [9468, 1509, 1], [9468, 1510, 1], [9468, 1511, 1], [9468, 1512, 1], [9468, 1513, 1], [9468, 1514, 1], [9468, 1515, 1], [9468, 1516, 1], [9468, 1517, 1], [9468, 1518, 1], [9468, 1519, 1], [9468, 1520, 1], [9468, 1521, 1], [9468, 1522, 1], [9468, 1523, 1], [9468, 1524, 1], [9468, 1525, 1], [9468, 1526, 1], [9468, 1527, 1], [9468, 1528, 1], [9468, 1529, 1], [9468, 1530, 1], [9468, 1531, 1], [9468, 1532, 1], [9468, 1533, 1], [9468, 1534, 1], [9468, 1535, 1], [9468, 1536, 1], [9468, 1537, 1], [9468, 1538, 1], [9468, 1539, 1], [9468, 1540, 1], [9468, 1541, 1], [9468, 1542, 1], [9468, 1543, 1], [9468, 1544, 1], [9468, 1545, 1], [9468, 1546, 1], [9468, 1547, 1], [9468, 1548, 1], [9468, 1549, 1], [9468, 1550, 1], [9468, 1551, 1], [9468, 1552, 1], [9468, 1553, 1], [9468, 1554, 1], [9468, 1555, 1], [9468, 1556, 1], [9468, 1557, 1], [9468, 1558, 1], [9468, 1559, 1], [9468, 1560, 1], [9468, 1561, 1], [9468, 1562, 1], [9468, 1563, 1], [9468, 1564, 1], [9468, 1565, 1], [9468, 1566, 1], [9468, 1567, 1], [9468, 1568, 1], [9468, 1569, 1], [9468, 1570, 1], [9468, 1571, 1], [9468, 1572, 1], [9468, 1573, 1], [9468, 1574, 1], [9468, 1575, 1], [9468, 1576, 1], [9468, 1577, 1], [9468, 1578, 1], [9468, 1579, 1], [9468, 1580, 1], [9468, 1581, 1], [9468, 1582, 1], [9468, 1583, 1], [9468, 1584, 1], [9468, 1585, 1], [9468, 1586, 1], [9468, 1587, 1], [9468, 1588, 1], [9468, 1589, 1], [9468, 1590, 1], [9468, 1591, 1], [9468, 1592, 1], [9468, 1593, 1], [9468, 1594, 1], [9468, 1595, 1], [9468, 1596, 1], [9468, 1597, 1], [9468, 1598, 1], [9468, 1599, 1], [9468, 1600, 1], [9468, 1601, 1], [9468, 1602, 1], [9468, 1603, 1], [968, 969, 1], [1023, 1036, 1], [981, 9455, 1], [9455, 918, 1], [9455, 3564, 1], [9455, 3565, 1], [9455, 3566, 1], [9455, 3567, 1], [9455, 3568, 1], [9455, 3569, 1], [9455, 3570, 1], [9455, 3571, 1], [9455, 3572, 1], [9455, 3573, 1], [9455, 3574, 1], [9455, 3575, 1], [9455, 3576, 1], [9455, 3577, 1], [9455, 3578, 1], [9455, 3579, 1], [9455, 3580, 1], [9455, 3581, 1], [9455, 3582, 1], [9455, 3583, 1], [9455, 3584, 1], [9455, 3585, 1], [9455, 3586, 1], [9455, 3587, 1], [9455, 3588, 1], [9455, 3589, 1], [9455, 3590, 1], [9455, 3591, 1], [9455, 3592, 1], [9455, 3593, 1], [9455, 3594, 1], [9455, 3595, 1], [9455, 3596, 1], [9455, 3597, 1], [9455, 3598, 1], [9455, 3599, 1], [9455, 3600, 1], [9455, 3601, 1], [9455, 3602, 1], [9455, 3603, 1], [9455, 3604, 1], [9455, 3605, 1], [9455, 3606, 1], [9455, 3607, 1], [9455, 3608, 1], [9455, 3609, 1], [9455, 3610, 1], [9455, 3611, 1], [9455, 3612, 1], [9455, 3613, 1], [9455, 3614, 1], [9455, 3615, 1], [9455, 3616, 1], [9455, 3617, 1], [9455, 3618, 1], [9455, 3619, 1], [9455, 3620, 1], [9455, 3621, 1], [9455, 3622, 1], [9455, 3623, 1], [9455, 3624, 1], [9455, 3625, 1], [9455, 3626, 1], [9455, 3627, 1], [9455, 3628, 1], [9455, 3629, 1], [9455, 3630, 1], [9455, 3631, 1], [9455, 3632, 1], [9455, 3633, 1], [9455, 3634, 1], [9455, 3635, 1], [9455, 3636, 1], [9455, 3637, 1], [9455, 3638, 1], [9455, 3639, 1], [9455, 3640, 1], [9455, 3641, 1], [9455, 3642, 1], [9455, 3643, 1], [9455, 3644, 1], [9455, 3645, 1], [9455, 3646, 1], [9455, 3647, 1], [9455, 3648, 1], [9455, 3649, 1], [9455, 3650, 1], [9455, 3651, 1], [9455, 3652, 1], [9455, 3653, 1], [9455, 3654, 1], [9455, 3655, 1], [9455, 3656, 1], [9455, 3657, 1], [9455, 3658, 1], [9455, 3659, 1], [9455, 3660, 1], [9455, 3661, 1], [9455, 3662, 1], [9455, 3663, 1], [9455, 3664, 1], [9455, 3665, 1], [9455, 3666, 1], [9455, 3667, 1], [9455, 3668, 1], [9455, 3669, 1], [9455, 3670, 1], [9455, 3671, 1], [9455, 3672, 1], [9455, 3673, 1], [9455, 3674, 1], [9455, 3675, 1], [9455, 3676, 1], [9455, 3677, 1], [9455, 3678, 1], [9455, 3679, 1], [9455, 3680, 1], [9455, 3681, 1], [9455, 3682, 1], [9455, 3683, 1], [9455, 3684, 1], [9455, 3685, 1], [9455, 3686, 1], [9455, 3687, 1], [9455, 3688, 1], [9455, 3689, 1], [9455, 3690, 1], [9455, 3691, 1], [9455, 3692, 1], [9455, 3693, 1], [9455, 3694, 1], [9455, 3695, 1], [9455, 3696, 1], [9455, 3697, 1], [9455, 3698, 1], [9455, 3699, 1], [9455, 3700, 1], [9455, 3701, 1], [9455, 3702, 1], [9455, 3703, 1], [9455, 4264, 1], [9455, 4265, 1], [9455, 4266, 1], [9455, 4267, 1], [9455, 4268, 1], [9455, 4269, 1], [9455, 4270, 1], [9455, 4271, 1], [9455, 4272, 1], [9455, 4273, 1], [9455, 4274, 1], [9455, 4275, 1], [9455, 4276, 1], [9455, 4277, 1], [9455, 4278, 1], [9455, 4279, 1], [9455, 4280, 1], [9455, 4281, 1], [9455, 4282, 1], [9455, 4283, 1], [9455, 4284, 1], [9455, 4285, 1], [9455, 4286, 1], [9455, 4287, 1], [9455, 4288, 1], [9455, 4289, 1], [9455, 4290, 1], [9455, 4291, 1], [9455, 4292, 1], [9455, 4293, 1], [9455, 4294, 1], [9455, 4295, 1], [9455, 4296, 1], [9455, 4297, 1], [9455, 4298, 1], [9455, 4299, 1], [9455, 4300, 1], [9455, 4301, 1], [9455, 4302, 1], [9455, 4303, 1], [9455, 4304, 1], [9455, 4305, 1], [9455, 4306, 1], [9455, 4307, 1], [9455, 4308, 1], [9455, 4309, 1], [9455, 4310, 1], [9455, 4311, 1], [9455, 4312, 1], [9455, 4313, 1], [9455, 4314, 1], [9455, 4315, 1], [9455, 4316, 1], [9455, 4317, 1], [9455, 4318, 1], [9455, 4319, 1], [9455, 4320, 1], [9455, 4321, 1], [9455, 4322, 1], [9455, 4323, 1], [9455, 4324, 1], [9455, 4325, 1], [9455, 4326, 1], [9455, 4327, 1], [9455, 4328, 1], [9455, 4329, 1], [9455, 4330, 1], [9455, 4331, 1], [9455, 4332, 1], [9455, 4333, 1], [9455, 4334, 1], [9455, 4335, 1], [9455, 4336, 1], [9455, 4337, 1], [9455, 4338, 1], [9455, 4339, 1], [9455, 4340, 1], [9455, 4341, 1], [9455, 4342, 1], [9455, 4343, 1], [9455, 4344, 1], [9455, 4345, 1], [9455, 4346, 1], [9455, 4347, 1], [9455, 4348, 1], [9455, 4349, 1], [9455, 4350, 1], [9455, 4351, 1], [9455, 4352, 1], [9455, 4353, 1], [9455, 4354, 1], [9455, 4355, 1], [9455, 4356, 1], [9455, 4357, 1], [9455, 4358, 1], [9455, 4359, 1], [9455, 4360, 1], [9455, 4361, 1], [9455, 4362, 1], [9455, 4363, 1], [9455, 4364, 1], [9455, 4365, 1], [9455, 4366, 1], [9455, 4367, 1], [9455, 4368, 1], [9455, 4369, 1], [9455, 4370, 1], [9455, 4371, 1], [9455, 4372, 1], [9455, 4373, 1], [9455, 4374, 1], [9455, 4375, 1], [9455, 4376, 1], [9455, 4377, 1], [9455, 4378, 1], [9455, 4379, 1], [9455, 4380, 1], [9455, 4381, 1], [9455, 4382, 1], [9455, 4383, 1], [9455, 4384, 1], [9455, 4385, 1], [9455, 4386, 1], [9455, 4387, 1], [9455, 4388, 1], [9455, 4389, 1], [9455, 4390, 1], [9455, 4391, 1], [9455, 4392, 1], [9455, 4393, 1], [9455, 4394, 1], [9455, 4395, 1], [9455, 4396, 1], [9455, 4397, 1], [9455, 4398, 1], [9455, 4399, 1], [9455, 4400, 1], [9455, 4401, 1], [9455, 4402, 1], [9455, 4403, 1], [960, 961, 1], [1002, 1003, 1], [722, 606, 1], [606, 607, 1], [1022, 1023, 1], [934, 935, 1], [1007, 1038, 1], [938, 939, 1], [1019, 1036, 1], [956, 957, 1], [944, 945, 1], [975, 9456, 1], [9456, 914, 1], [9456, 1884, 1], [9456, 1885, 1], [9456, 1886, 1], [9456, 1887, 1], [9456, 1888, 1], [9456, 1889, 1], [9456, 1890, 1], [9456, 1891, 1], [9456, 1892, 1], [9456, 1893, 1], [9456, 1894, 1], [9456, 1895, 1], [9456, 1896, 1], [9456, 1897, 1], [9456, 1898, 1], [9456, 1899, 1], [9456, 1900, 1], [9456, 1901, 1], [9456, 1902, 1], [9456, 1903, 1], [9456, 1904, 1], [9456, 1905, 1], [9456, 1906, 1], [9456, 1907, 1], [9456, 1908, 1], [9456, 1909, 1], [9456, 1910, 1], [9456, 1911, 1], [9456, 1912, 1], [9456, 1913, 1], [9456, 1914, 1], [9456, 1915, 1], [9456, 1916, 1], [9456, 1917, 1], [9456, 1918, 1], [9456, 1919, 1], [9456, 1920, 1], [9456, 1921, 1], [9456, 1922, 1], [9456, 1923, 1], [9456, 1924, 1], [9456, 1925, 1], [9456, 1926, 1], [9456, 1927, 1], [9456, 1928, 1], [9456, 1929, 1], [9456, 1930, 1], [9456, 1931, 1], [9456, 1932, 1], [9456, 1933, 1], [9456, 1934, 1], [9456, 1935, 1], [9456, 1936, 1], [9456, 1937, 1], [9456, 1938, 1], [9456, 1939, 1], [9456, 1940, 1], [9456, 1941, 1], [9456, 1942, 1], [9456, 1943, 1], [9456, 1944, 1], [9456, 1945, 1], [9456, 1946, 1], [9456, 1947, 1], [9456, 1948, 1], [9456, 1949, 1], [9456, 1950, 1], [9456, 1951, 1], [9456, 1952, 1], [9456, 1953, 1], [9456, 1954, 1], [9456, 1955, 1], [9456, 1956, 1], [9456, 1957, 1], [9456, 1958, 1], [9456, 1959, 1], [9456, 1960, 1], [9456, 1961, 1], [9456, 1962, 1], [9456, 1963, 1], [9456, 1964, 1], [9456, 1965, 1], [9456, 1966, 1], [9456, 1967, 1], [9456, 1968, 1], [9456, 1969, 1], [9456, 1970, 1], [9456, 1971, 1], [9456, 1972, 1], [9456, 1973, 1], [9456, 1974, 1], [9456, 1975, 1], [9456, 1976, 1], [9456, 1977, 1], [9456, 1978, 1], [9456, 1979, 1], [9456, 1980, 1], [9456, 1981, 1], [9456, 1982, 1], [9456, 1983, 1], [9456, 1984, 1], [9456, 1985, 1], [9456, 1986, 1], [9456, 1987, 1], [9456, 1988, 1], [9456, 1989, 1], [9456, 1990, 1], [9456, 1991, 1], [9456, 1992, 1], [9456, 1993, 1], [9456, 1994, 1], [9456, 1995, 1], [9456, 1996, 1], [9456, 1997, 1], [9456, 1998, 1], [9456, 1999, 1], [9456, 2000, 1], [9456, 2001, 1], [9456, 2002, 1], [9456, 2003, 1], [9456, 2004, 1], [9456, 2005, 1], [9456, 2006, 1], [9456, 2007, 1], [9456, 2008, 1], [9456, 2009, 1], [9456, 2010, 1], [9456, 2011, 1], [9456, 2012, 1], [9456, 2013, 1], [9456, 2014, 1], [9456, 2015, 1], [9456, 2016, 1], [9456, 2017, 1], [9456, 2018, 1], [9456, 2019, 1], [9456, 2020, 1], [9456, 2021, 1], [9456, 2022, 1], [9456, 2023, 1], [9456, 2584, 1], [9456, 2585, 1], [9456, 2586, 1], [9456, 2587, 1], [9456, 2588, 1], [9456, 2589, 1], [9456, 2590, 1], [9456, 2591, 1], [9456, 2592, 1], [9456, 2593, 1], [9456, 2594, 1], [9456, 2595, 1], [9456, 2596, 1], [9456, 2597, 1], [9456, 2598, 1], [9456, 2599, 1], [9456, 2600, 1], [9456, 2601, 1], [9456, 2602, 1], [9456, 2603, 1], [9456, 2604, 1], [9456, 2605, 1], [9456, 2606, 1], [9456, 2607, 1], [9456, 2608, 1], [9456, 2609, 1], [9456, 2610, 1], [9456, 2611, 1], [9456, 2612, 1], [9456, 2613, 1], [9456, 2614, 1], [9456, 2615, 1], [9456, 2616, 1], [9456, 2617, 1], [9456, 2618, 1], [9456, 2619, 1], [9456, 2620, 1], [9456, 2621, 1], [9456, 2622, 1], [9456, 2623, 1], [9456, 2624, 1], [9456, 2625, 1], [9456, 2626, 1], [9456, 2627, 1], [9456, 2628, 1], [9456, 2629, 1], [9456, 2630, 1], [9456, 2631, 1], [9456, 2632, 1], [9456, 2633, 1], [9456, 2634, 1], [9456, 2635, 1], [9456, 2636, 1], [9456, 2637, 1], [9456, 2638, 1], [9456, 2639, 1], [9456, 2640, 1], [9456, 2641, 1], [9456, 2642, 1], [9456, 2643, 1], [9456, 2644, 1], [9456, 2645, 1], [9456, 2646, 1], [9456, 2647, 1], [9456, 2648, 1], [9456, 2649, 1], [9456, 2650, 1], [9456, 2651, 1], [9456, 2652, 1], [9456, 2653, 1], [9456, 2654, 1], [9456, 2655, 1], [9456, 2656, 1], [9456, 2657, 1], [9456, 2658, 1], [9456, 2659, 1], [9456, 2660, 1], [9456, 2661, 1], [9456, 2662, 1], [9456, 2663, 1], [9456, 2664, 1], [9456, 2665, 1], [9456, 2666, 1], [9456, 2667, 1], [9456, 2668, 1], [9456, 2669, 1], [9456, 2670, 1], [9456, 2671, 1], [9456, 2672, 1], [9456, 2673, 1], [9456, 2674, 1], [9456, 2675, 1], [9456, 2676, 1], [9456, 2677, 1], [9456, 2678, 1], [9456, 2679, 1], [9456, 2680, 1], [9456, 2681, 1], [9456, 2682, 1], [9456, 2683, 1], [9456, 2684, 1], [9456, 2685, 1], [9456, 2686, 1], [9456, 2687, 1], [9456, 2688, 1], [9456, 2689, 1], [9456, 2690, 1], [9456, 2691, 1], [9456, 2692, 1], [9456, 2693, 1], [9456, 2694, 1], [9456, 2695, 1], [9456, 2696, 1], [9456, 2697, 1], [9456, 2698, 1], [9456, 2699, 1], [9456, 2700, 1], [9456, 2701, 1], [9456, 2702, 1], [9456, 2703, 1], [9456, 2704, 1], [9456, 2705, 1], [9456, 2706, 1], [9456, 2707, 1], [9456, 2708, 1], [9456, 2709, 1], [9456, 2710, 1], [9456, 2711, 1], [9456, 2712, 1], [9456, 2713, 1], [9456, 2714, 1], [9456, 2715, 1], [9456, 2716, 1], [9456, 2717, 1], [9456, 2718, 1], [9456, 2719, 1], [9456, 2720, 1], [9456, 2721, 1], [9456, 2722, 1], [9456, 2723, 1], [967, 9447, 1], [780, 781, 1], [187, 863, 1], [863, 189, 1], [920, 921, 1], [916, 917, 1], [964, 965, 1], [9463, 912, 1], [9463, 1044, 1], [9463, 1045, 1], [9463, 1046, 1], [9463, 1047, 1], [9463, 1048, 1], [9463, 1049, 1], [9463, 1050, 1], [9463, 1051, 1], [9463, 1052, 1], [9463, 1053, 1], [9463, 1054, 1], [9463, 1055, 1], [9463, 1056, 1], [9463, 1057, 1], [9463, 1058, 1], [9463, 1059, 1], [9463, 1060, 1], [9463, 1061, 1], [9463, 1062, 1], [9463, 1063, 1], [9463, 1064, 1], [9463, 1065, 1], [9463, 1066, 1], [9463, 1067, 1], [9463, 1068, 1], [9463, 1069, 1], [9463, 1070, 1], [9463, 1071, 1], [9463, 1072, 1], [9463, 1073, 1], [9463, 1074, 1], [9463, 1075, 1], [9463, 1076, 1], [9463, 1077, 1], [9463, 1078, 1], [9463, 1079, 1], [9463, 1080, 1], [9463, 1081, 1], [9463, 1082, 1], [9463, 1083, 1], [9463, 1084, 1], [9463, 1085, 1], [9463, 1086, 1], [9463, 1087, 1], [9463, 1088, 1], [9463, 1089, 1], [9463, 1090, 1], [9463, 1091, 1], [9463, 1092, 1], [9463, 1093, 1], [9463, 1094, 1], [9463, 1095, 1], [9463, 1096, 1], [9463, 1097, 1], [9463, 1098, 1], [9463, 1099, 1], [9463, 1100, 1], [9463, 1101, 1], [9463, 1102, 1], [9463, 1103, 1], [9463, 1104, 1], [9463, 1105, 1], [9463, 1106, 1], [9463, 1107, 1], [9463, 1108, 1], [9463, 1109, 1], [9463, 1110, 1], [9463, 1111, 1], [9463, 1112, 1], [9463, 1113, 1], [9463, 1114, 1], [9463, 1115, 1], [9463, 1116, 1], [9463, 1117, 1], [9463, 1118, 1], [9463, 1119, 1], [9463, 1120, 1], [9463, 1121, 1], [9463, 1122, 1], [9463, 1123, 1], [9463, 1124, 1], [9463, 1125, 1], [9463, 1126, 1], [9463, 1127, 1], [9463, 1128, 1], [9463, 1129, 1], [9463, 1130, 1], [9463, 1131, 1], [9463, 1132, 1], [9463, 1133, 1], [9463, 1134, 1], [9463, 1135, 1], [9463, 1136, 1], [9463, 1137, 1], [9463, 1138, 1], [9463, 1139, 1], [9463, 1140, 1], [9463, 1141, 1], [9463, 1142, 1], [9463, 1143, 1], [9463, 1144, 1], [9463, 1145, 1], [9463, 1146, 1], [9463, 1147, 1], [9463, 1148, 1], [9463, 1149, 1], [9463, 1150, 1], [9463, 1151, 1], [9463, 1152, 1], [9463, 1153, 1], [9463, 1154, 1], [9463, 1155, 1], [9463, 1156, 1], [9463, 1157, 1], [9463, 1158, 1], [9463, 1159, 1], [9463, 1160, 1], [9463, 1161, 1], [9463, 1162, 1], [9463, 1163, 1], [9463, 1164, 1], [9463, 1165, 1], [9463, 1166, 1], [9463, 1167, 1], [9463, 1168, 1], [9463, 1169, 1], [9463, 1170, 1], [9463, 1171, 1], [9463, 1172, 1], [9463, 1173, 1], [9463, 1174, 1], [9463, 1175, 1], [9463, 1176, 1], [9463, 1177, 1], [9463, 1178, 1], [9463, 1179, 1], [9463, 1180, 1], [9463, 1181, 1], [9463, 1182, 1], [9463, 1183, 1], [9463, 1744, 1], [9463, 1745, 1], [9463, 1746, 1], [9463, 1747, 1], [9463, 1748, 1], [9463, 1749, 1], [9463, 1750, 1], [9463, 1751, 1], [9463, 1752, 1], [9463, 1753, 1], [9463, 1754, 1], [9463, 1755, 1], [9463, 1756, 1], [9463, 1757, 1], [9463, 1758, 1], [9463, 1759, 1], [9463, 1760, 1], [9463, 1761, 1], [9463, 1762, 1], [9463, 1763, 1], [9463, 1764, 1], [9463, 1765, 1], [9463, 1766, 1], [9463, 1767, 1], [9463, 1768, 1], [9463, 1769, 1], [9463, 1770, 1], [9463, 1771, 1], [9463, 1772, 1], [9463, 1773, 1], [9463, 1774, 1], [9463, 1775, 1], [9463, 1776, 1], [9463, 1777, 1], [9463, 1778, 1], [9463, 1779, 1], [9463, 1780, 1], [9463, 1781, 1], [9463, 1782, 1], [9463, 1783, 1], [9463, 1784, 1], [9463, 1785, 1], [9463, 1786, 1], [9463, 1787, 1], [9463, 1788, 1], [9463, 1789, 1], [9463, 1790, 1], [9463, 1791, 1], [9463, 1792, 1], [9463, 1793, 1], [9463, 1794, 1], [9463, 1795, 1], [9463, 1796, 1], [9463, 1797, 1], [9463, 1798, 1], [9463, 1799, 1], [9463, 1800, 1], [9463, 1801, 1], [9463, 1802, 1], [9463, 1803, 1], [9463, 1804, 1], [9463, 1805, 1], [9463, 1806, 1], [9463, 1807, 1], [9463, 1808, 1], [9463, 1809, 1], [9463, 1810, 1], [9463, 1811, 1], [9463, 1812, 1], [9463, 1813, 1], [9463, 1814, 1], [9463, 1815, 1], [9463, 1816, 1], [9463, 1817, 1], [9463, 1818, 1], [9463, 1819, 1], [9463, 1820, 1], [9463, 1821, 1], [9463, 1822, 1], [9463, 1823, 1], [9463, 1824, 1], [9463, 1825, 1], [9463, 1826, 1], [9463, 1827, 1], [9463, 1828, 1], [9463, 1829, 1], [9463, 1830, 1], [9463, 1831, 1], [9463, 1832, 1], [9463, 1833, 1], [9463, 1834, 1], [9463, 1835, 1], [9463, 1836, 1], [9463, 1837, 1], [9463, 1838, 1], [9463, 1839, 1], [9463, 1840, 1], [9463, 1841, 1], [9463, 1842, 1], [9463, 1843, 1], [9463, 1844, 1], [9463, 1845, 1], [9463, 1846, 1], [9463, 1847, 1], [9463, 1848, 1], [9463, 1849, 1], [9463, 1850, 1], [9463, 1851, 1], [9463, 1852, 1], [9463, 1853, 1], [9463, 1854, 1], [9463, 1855, 1], [9463, 1856, 1], [9463, 1857, 1], [9463, 1858, 1], [9463, 1859, 1], [9463, 1860, 1], [9463, 1861, 1], [9463, 1862, 1], [9463, 1863, 1], [9463, 1864, 1], [9463, 1865, 1], [9463, 1866, 1], [9463, 1867, 1], [9463, 1868, 1], [9463, 1869, 1], [9463, 1870, 1], [9463, 1871, 1], [9463, 1872, 1], [9463, 1873, 1], [9463, 1874, 1], [9463, 1875, 1], [9463, 1876, 1], [9463, 1877, 1], [9463, 1878, 1], [9463, 1879, 1], [9463, 1880, 1], [9463, 1881, 1], [9463, 1882, 1], [9463, 1883, 1], [912, 913, 1], [1031, 1036, 1], [923, 1034, 1], [838, 422, 1], [422, 423, 1], [969, 9451, 1], [9451, 992, 1], [9451, 7904, 1], [9451, 7905, 1], [9451, 7906, 1], [9451, 7907, 1], [9451, 7908, 1], [9451, 7909, 1], [9451, 7910, 1], [9451, 7911, 1], [9451, 7912, 1], [9451, 7913, 1], [9451, 7914, 1], [9451, 7915, 1], [9451, 7916, 1], [9451, 7917, 1], [9451, 7918, 1], [9451, 7919, 1], [9451, 7920, 1], [9451, 7921, 1], [9451, 7922, 1], [9451, 7923, 1], [9451, 7924, 1], [9451, 7925, 1], [9451, 7926, 1], [9451, 7927, 1], [9451, 7928, 1], [9451, 7929, 1], [9451, 7930, 1], [9451, 7931, 1], [9451, 7932, 1], [9451, 7933, 1], [9451, 7934, 1], [9451, 7935, 1], [9451, 7936, 1], [9451, 7937, 1], [9451, 7938, 1], [9451, 7939, 1], [9451, 7940, 1], [9451, 7941, 1], [9451, 7942, 1], [9451, 7943, 1], [9451, 7944, 1], [9451, 7945, 1], [9451, 7946, 1], [9451, 7947, 1], [9451, 7948, 1], [9451, 7949, 1], [9451, 7950, 1], [9451, 7951, 1], [9451, 7952, 1], [9451, 7953, 1], [9451, 7954, 1], [9451, 7955, 1], [9451, 7956, 1], [9451, 7957, 1], [9451, 7958, 1], [9451, 7959, 1], [9451, 7960, 1], [9451, 7961, 1], [9451, 7962, 1], [9451, 7963, 1], [9451, 7964, 1], [9451, 7965, 1], [9451, 7966, 1], [9451, 7967, 1], [9451, 7968, 1], [9451, 7969, 1], [9451, 7970, 1], [9451, 7971, 1], [9451, 7972, 1], [9451, 7973, 1], [9451, 7974, 1], [9451, 7975, 1], [9451, 7976, 1], [9451, 7977, 1], [9451, 7978, 1], [9451, 7979, 1], [9451, 7980, 1], [9451, 7981, 1], [9451, 7982, 1], [9451, 7983, 1], [9451, 7984, 1], [9451, 7985, 1], [9451, 7986, 1], [9451, 7987, 1], [9451, 7988, 1], [9451, 7989, 1], [9451, 7990, 1], [9451, 7991, 1], [9451, 7992, 1], [9451, 7993, 1], [9451, 7994, 1], [9451, 7995, 1], [9451, 7996, 1], [9451, 7997, 1], [9451, 7998, 1], [9451, 7999, 1], [9451, 8000, 1], [9451, 8001, 1], [9451, 8002, 1], [9451, 8003, 1], [9451, 8004, 1], [9451, 8005, 1], [9451, 8006, 1], [9451, 8007, 1], [9451, 8008, 1], [9451, 8009, 1], [9451, 8010, 1], [9451, 8011, 1], [9451, 8012, 1], [9451, 8013, 1], [9451, 8014, 1], [9451, 8015, 1], [9451, 8016, 1], [9451, 8017, 1], [9451, 8018, 1], [9451, 8019, 1], [9451, 8020, 1], [9451, 8021, 1], [9451, 8022, 1], [9451, 8023, 1], [9451, 8024, 1], [9451, 8025, 1], [9451, 8026, 1], [9451, 8027, 1], [9451, 8028, 1], [9451, 8029, 1], [9451, 8030, 1], [9451, 8031, 1], [9451, 8032, 1], [9451, 8033, 1], [9451, 8034, 1], [9451, 8035, 1], [9451, 8036, 1], [9451, 8037, 1], [9451, 8038, 1], [9451, 8039, 1], [9451, 8040, 1], [9451, 8041, 1], [9451, 8042, 1], [9451, 8043, 1], [9451, 8324, 1], [9451, 8325, 1], [9451, 8326, 1], [9451, 8327, 1], [9451, 8328, 1], [9451, 8329, 1], [9451, 8330, 1], [9451, 8331, 1], [9451, 8332, 1], [9451, 8333, 1], [9451, 8334, 1], [9451, 8335, 1], [9451, 8336, 1], [9451, 8337, 1], [9451, 8338, 1], [9451, 8339, 1], [9451, 8340, 1], [9451, 8341, 1], [9451, 8342, 1], [9451, 8343, 1], [9451, 8344, 1], [9451, 8345, 1], [9451, 8346, 1], [9451, 8347, 1], [9451, 8348, 1], [9451, 8349, 1], [9451, 8350, 1], [9451, 8351, 1], [9451, 8352, 1], [9451, 8353, 1], [9451, 8354, 1], [9451, 8355, 1], [9451, 8356, 1], [9451, 8357, 1], [9451, 8358, 1], [9451, 8359, 1], [9451, 8360, 1], [9451, 8361, 1], [9451, 8362, 1], [9451, 8363, 1], [9451, 8364, 1], [9451, 8365, 1], [9451, 8366, 1], [9451, 8367, 1], [9451, 8368, 1], [9451, 8369, 1], [9451, 8370, 1], [9451, 8371, 1], [9451, 8372, 1], [9451, 8373, 1], [9451, 8374, 1], [9451, 8375, 1], [9451, 8376, 1], [9451, 8377, 1], [9451, 8378, 1], [9451, 8379, 1], [9451, 8380, 1], [9451, 8381, 1], [9451, 8382, 1], [9451, 8383, 1], [9451, 8384, 1], [9451, 8385, 1], [9451, 8386, 1], [9451, 8387, 1], [9451, 8388, 1], [9451, 8389, 1], [9451, 8390, 1], [9451, 8391, 1], [9451, 8392, 1], [9451, 8393, 1], [9451, 8394, 1], [9451, 8395, 1], [9451, 8396, 1], [9451, 8397, 1], [9451, 8398, 1], [9451, 8399, 1], [9451, 8400, 1], [9451, 8401, 1], [9451, 8402, 1], [9451, 8403, 1], [9451, 8404, 1], [9451, 8405, 1], [9451, 8406, 1], [9451, 8407, 1], [9451, 8408, 1], [9451, 8409, 1], [9451, 8410, 1], [9451, 8411, 1], [9451, 8412, 1], [9451, 8413, 1], [9451, 8414, 1], [9451, 8415, 1], [9451, 8416, 1], [9451, 8417, 1], [9451, 8418, 1], [9451, 8419, 1], [9451, 8420, 1], [9451, 8421, 1], [9451, 8422, 1], [9451, 8423, 1], [9451, 8424, 1], [9451, 8425, 1], [9451, 8426, 1], [9451, 8427, 1], [9451, 8428, 1], [9451, 8429, 1], [9451, 8430, 1], [9451, 8431, 1], [9451, 8432, 1], [9451, 8433, 1], [9451, 8434, 1], [9451, 8435, 1], [9451, 8436, 1], [9451, 8437, 1], [9451, 8438, 1], [9451, 8439, 1], [9451, 8440, 1], [9451, 8441, 1], [9451, 8442, 1], [9451, 8443, 1], [9451, 8444, 1], [9451, 8445, 1], [9451, 8446, 1], [9451, 8447, 1], [9451, 8448, 1], [9451, 8449, 1], [9451, 8450, 1], [9451, 8451, 1], [9451, 8452, 1], [9451, 8453, 1], [9451, 8454, 1], [9451, 8455, 1], [9451, 8456, 1], [9451, 8457, 1], [9451, 8458, 1], [9451, 8459, 1], [9451, 8460, 1], [9451, 8461, 1], [9451, 8462, 1], [9451, 8463, 1], [926, 927, 1], [970, 971, 1], [278, 279, 1], [189, 190, 1], [779, 320, 1], [12, 176, 1], [176, 177, 1], [983, 9463, 1], [728, 195, 1], [195, 182, 1], [397, 398, 1], [936, 937, 1], [941, 9473, 1], [9473, 1014, 1], [9473, 6364, 1], [9473, 6365, 1], [9473, 6366, 1], [9473, 6367, 1], [9473, 6368, 1], [9473, 6369, 1], [9473, 6370, 1], [9473, 6371, 1], [9473, 6372, 1], [9473, 6373, 1], [9473, 6374, 1], [9473, 6375, 1], [9473, 6376, 1], [9473, 6377, 1], [9473, 6378, 1], [9473, 6379, 1], [9473, 6380, 1], [9473, 6381, 1], [9473, 6382, 1], [9473, 6383, 1], [9473, 6384, 1], [9473, 6385, 1], [9473, 6386, 1], [9473, 6387, 1], [9473, 6388, 1], [9473, 6389, 1], [9473, 6390, 1], [9473, 6391, 1], [9473, 6392, 1], [9473, 6393, 1], [9473, 6394, 1], [9473, 6395, 1], [9473, 6396, 1], [9473, 6397, 1], [9473, 6398, 1], [9473, 6399, 1], [9473, 6400, 1], [9473, 6401, 1], [9473, 6402, 1], [9473, 6403, 1], [9473, 6404, 1], [9473, 6405, 1], [9473, 6406, 1], [9473, 6407, 1], [9473, 6408, 1], [9473, 6409, 1], [9473, 6410, 1], [9473, 6411, 1], [9473, 6412, 1], [9473, 6413, 1], [9473, 6414, 1], [9473, 6415, 1], [9473, 6416, 1], [9473, 6417, 1], [9473, 6418, 1], [9473, 6419, 1], [9473, 6420, 1], [9473, 6421, 1], [9473, 6422, 1], [9473, 6423, 1], [9473, 6424, 1], [9473, 6425, 1], [9473, 6426, 1], [9473, 6427, 1], [9473, 6428, 1], [9473, 6429, 1], [9473, 6430, 1], [9473, 6431, 1], [9473, 6432, 1], [9473, 6433, 1], [9473, 6434, 1], [9473, 6435, 1], [9473, 6436, 1], [9473, 6437, 1], [9473, 6438, 1], [9473, 6439, 1], [9473, 6440, 1], [9473, 6441, 1], [9473, 6442, 1], [9473, 6443, 1], [9473, 6444, 1], [9473, 6445, 1], [9473, 6446, 1], [9473, 6447, 1], [9473, 6448, 1], [9473, 6449, 1], [9473, 6450, 1], [9473, 6451, 1], [9473, 6452, 1], [9473, 6453, 1], [9473, 6454, 1], [9473, 6455, 1], [9473, 6456, 1], [9473, 6457, 1], [9473, 6458, 1], [9473, 6459, 1], [9473, 6460, 1], [9473, 6461, 1], [9473, 6462, 1], [9473, 6463, 1], [9473, 6464, 1], [9473, 6465, 1], [9473, 6466, 1], [9473, 6467, 1], [9473, 6468, 1], [9473, 6469, 1], [9473, 6470, 1], [9473, 6471, 1], [9473, 6472, 1], [9473, 6473, 1], [9473, 6474, 1], [9473, 6475, 1], [9473, 6476, 1], [9473, 6477, 1], [9473, 6478, 1], [9473, 6479, 1], [9473, 6480, 1], [9473, 6481, 1], [9473, 6482, 1], [9473, 6483, 1], [9473, 6484, 1], [9473, 6485, 1], [9473, 6486, 1], [9473, 6487, 1], [9473, 6488, 1], [9473, 6489, 1], [9473, 6490, 1], [9473, 6491, 1], [9473, 6492, 1], [9473, 6493, 1], [9473, 6494, 1], [9473, 6495, 1], [9473, 6496, 1], [9473, 6497, 1], [9473, 6498, 1], [9473, 6499, 1], [9473, 6500, 1], [9473, 6501, 1], [9473, 6502, 1], [9473, 6503, 1], [9473, 6504, 1], [9473, 6505, 1], [9473, 6506, 1], [9473, 6507, 1], [9473, 6508, 1], [9473, 6509, 1], [9473, 6510, 1], [9473, 6511, 1], [9473, 6512, 1], [9473, 6513, 1], [9473, 6514, 1], [9473, 6515, 1], [9473, 6516, 1], [9473, 6517, 1], [9473, 6518, 1], [9473, 6519, 1], [9473, 6520, 1], [9473, 6521, 1], [9473, 6522, 1], [9473, 6523, 1], [9473, 6524, 1], [9473, 6525, 1], [9473, 6526, 1], [9473, 6527, 1], [9473, 6528, 1], [9473, 6529, 1], [9473, 6530, 1], [9473, 6531, 1], [9473, 6532, 1], [9473, 6533, 1], [9473, 6534, 1], [9473, 6535, 1], [9473, 6536, 1], [9473, 6537, 1], [9473, 6538, 1], [9473, 6539, 1], [9473, 6540, 1], [9473, 6541, 1], [9473, 6542, 1], [9473, 6543, 1], [9473, 6544, 1], [9473, 6545, 1], [9473, 6546, 1], [9473, 6547, 1], [9473, 6548, 1], [9473, 6549, 1], [9473, 6550, 1], [9473, 6551, 1], [9473, 6552, 1], [9473, 6553, 1], [9473, 6554, 1], [9473, 6555, 1], [9473, 6556, 1], [9473, 6557, 1], [9473, 6558, 1], [9473, 6559, 1], [9473, 6560, 1], [9473, 6561, 1], [9473, 6562, 1], [9473, 6563, 1], [9473, 6564, 1], [9473, 6565, 1], [9473, 6566, 1], [9473, 6567, 1], [9473, 6568, 1], [9473, 6569, 1], [9473, 6570, 1], [9473, 6571, 1], [9473, 6572, 1], [9473, 6573, 1], [9473, 6574, 1], [9473, 6575, 1], [9473, 6576, 1], [9473, 6577, 1], [9473, 6578, 1], [9473, 6579, 1], [9473, 6580, 1], [9473, 6581, 1], [9473, 6582, 1], [9473, 6583, 1], [9473, 6584, 1], [9473, 6585, 1], [9473, 6586, 1], [9473, 6587, 1], [9473, 6588, 1], [9473, 6589, 1], [9473, 6590, 1], [9473, 6591, 1], [9473, 6592, 1], [9473, 6593, 1], [9473, 6594, 1], [9473, 6595, 1], [9473, 6596, 1], [9473, 6597, 1], [9473, 6598, 1], [9473, 6599, 1], [9473, 6600, 1], [9473, 6601, 1], [9473, 6602, 1], [9473, 6603, 1], [9473, 6604, 1], [9473, 6605, 1], [9473, 6606, 1], [9473, 6607, 1], [9473, 6608, 1], [9473, 6609, 1], [9473, 6610, 1], [9473, 6611, 1], [9473, 6612, 1], [9473, 6613, 1], [9473, 6614, 1], [9473, 6615, 1], [9473, 6616, 1], [9473, 6617, 1], [9473, 6618, 1], [9473, 6619, 1], [9473, 6620, 1], [9473, 6621, 1], [9473, 6622, 1], [9473, 6623, 1], [9473, 6624, 1], [9473, 6625, 1], [9473, 6626, 1], [9473, 6627, 1], [9473, 6628, 1], [9473, 6629, 1], [9473, 6630, 1], [9473, 6631, 1], [9473, 6632, 1], [9473, 6633, 1], [9473, 6634, 1], [9473, 6635, 1], [9473, 6636, 1], [9473, 6637, 1], [9473, 6638, 1], [9473, 6639, 1], [9473, 6640, 1], [9473, 6641, 1], [9473, 6642, 1], [9473, 6643, 1], [198, 50, 1], [50, 51, 1], [839, 840, 1], [153, 722, 1], [915, 1034, 1], [661, 845, 1], [845, 846, 1], [1006, 1007, 1], [620, 790, 1], [790, 791, 1], [749, 621, 1], [621, 622, 1], [978, 979, 1], [914, 915, 1], [174, 154, 1], [154, 155, 1], [939, 9467, 1], [9467, 1028, 1], [9467, 7204, 1], [9467, 7205, 1], [9467, 7206, 1], [9467, 7207, 1], [9467, 7208, 1], [9467, 7209, 1], [9467, 7210, 1], [9467, 7211, 1], [9467, 7212, 1], [9467, 7213, 1], [9467, 7214, 1], [9467, 7215, 1], [9467, 7216, 1], [9467, 7217, 1], [9467, 7218, 1], [9467, 7219, 1], [9467, 7220, 1], [9467, 7221, 1], [9467, 7222, 1], [9467, 7223, 1], [9467, 7224, 1], [9467, 7225, 1], [9467, 7226, 1], [9467, 7227, 1], [9467, 7228, 1], [9467, 7229, 1], [9467, 7230, 1], [9467, 7231, 1], [9467, 7232, 1], [9467, 7233, 1], [9467, 7234, 1], [9467, 7235, 1], [9467, 7236, 1], [9467, 7237, 1], [9467, 7238, 1], [9467, 7239, 1], [9467, 7240, 1], [9467, 7241, 1], [9467, 7242, 1], [9467, 7243, 1], [9467, 7244, 1], [9467, 7245, 1], [9467, 7246, 1], [9467, 7247, 1], [9467, 7248, 1], [9467, 7249, 1], [9467, 7250, 1], [9467, 7251, 1], [9467, 7252, 1], [9467, 7253, 1], [9467, 7254, 1], [9467, 7255, 1], [9467, 7256, 1], [9467, 7257, 1], [9467, 7258, 1], [9467, 7259, 1], [9467, 7260, 1], [9467, 7261, 1], [9467, 7262, 1], [9467, 7263, 1], [9467, 7264, 1], [9467, 7265, 1], [9467, 7266, 1], [9467, 7267, 1], [9467, 7268, 1], [9467, 7269, 1], [9467, 7270, 1], [9467, 7271, 1], [9467, 7272, 1], [9467, 7273, 1], [9467, 7274, 1], [9467, 7275, 1], [9467, 7276, 1], [9467, 7277, 1], [9467, 7278, 1], [9467, 7279, 1], [9467, 7280, 1], [9467, 7281, 1], [9467, 7282, 1], [9467, 7283, 1], [9467, 7284, 1], [9467, 7285, 1], [9467, 7286, 1], [9467, 7287, 1], [9467, 7288, 1], [9467, 7289, 1], [9467, 7290, 1], [9467, 7291, 1], [9467, 7292, 1], [9467, 7293, 1], [9467, 7294, 1], [9467, 7295, 1], [9467, 7296, 1], [9467, 7297, 1], [9467, 7298, 1], [9467, 7299, 1], [9467, 7300, 1], [9467, 7301, 1], [9467, 7302, 1], [9467, 7303, 1], [9467, 7304, 1], [9467, 7305, 1], [9467, 7306, 1], [9467, 7307, 1], [9467, 7308, 1], [9467, 7309, 1], [9467, 7310, 1], [9467, 7311, 1], [9467, 7312, 1], [9467, 7313, 1], [9467, 7314, 1], [9467, 7315, 1], [9467, 7316, 1], [9467, 7317, 1], [9467, 7318, 1], [9467, 7319, 1], [9467, 7320, 1], [9467, 7321, 1], [9467, 7322, 1], [9467, 7323, 1], [9467, 7324, 1], [9467, 7325, 1], [9467, 7326, 1], [9467, 7327, 1], [9467, 7328, 1], [9467, 7329, 1], [9467, 7330, 1], [9467, 7331, 1], [9467, 7332, 1], [9467, 7333, 1], [9467, 7334, 1], [9467, 7335, 1], [9467, 7336, 1], [9467, 7337, 1], [9467, 7338, 1], [9467, 7339, 1], [9467, 7340, 1], [9467, 7341, 1], [9467, 7342, 1], [9467, 7343, 1], [9467, 7344, 1], [9467, 7345, 1], [9467, 7346, 1], [9467, 7347, 1], [9467, 7348, 1], [9467, 7349, 1], [9467, 7350, 1], [9467, 7351, 1], [9467, 7352, 1], [9467, 7353, 1], [9467, 7354, 1], [9467, 7355, 1], [9467, 7356, 1], [9467, 7357, 1], [9467, 7358, 1], [9467, 7359, 1], [9467, 7360, 1], [9467, 7361, 1], [9467, 7362, 1], [9467, 7363, 1], [9467, 7364, 1], [9467, 7365, 1], [9467, 7366, 1], [9467, 7367, 1], [9467, 7368, 1], [9467, 7369, 1], [9467, 7370, 1], [9467, 7371, 1], [9467, 7372, 1], [9467, 7373, 1], [9467, 7374, 1], [9467, 7375, 1], [9467, 7376, 1], [9467, 7377, 1], [9467, 7378, 1], [9467, 7379, 1], [9467, 7380, 1], [9467, 7381, 1], [9467, 7382, 1], [9467, 7383, 1], [9467, 7384, 1], [9467, 7385, 1], [9467, 7386, 1], [9467, 7387, 1], [9467, 7388, 1], [9467, 7389, 1], [9467, 7390, 1], [9467, 7391, 1], [9467, 7392, 1], [9467, 7393, 1], [9467, 7394, 1], [9467, 7395, 1], [9467, 7396, 1], [9467, 7397, 1], [9467, 7398, 1], [9467, 7399, 1], [9467, 7400, 1], [9467, 7401, 1], [9467, 7402, 1], [9467, 7403, 1], [9467, 7404, 1], [9467, 7405, 1], [9467, 7406, 1], [9467, 7407, 1], [9467, 7408, 1], [9467, 7409, 1], [9467, 7410, 1], [9467, 7411, 1], [9467, 7412, 1], [9467, 7413, 1], [9467, 7414, 1], [9467, 7415, 1], [9467, 7416, 1], [9467, 7417, 1], [9467, 7418, 1], [9467, 7419, 1], [9467, 7420, 1], [9467, 7421, 1], [9467, 7422, 1], [9467, 7423, 1], [9467, 7424, 1], [9467, 7425, 1], [9467, 7426, 1], [9467, 7427, 1], [9467, 7428, 1], [9467, 7429, 1], [9467, 7430, 1], [9467, 7431, 1], [9467, 7432, 1], [9467, 7433, 1], [9467, 7434, 1], [9467, 7435, 1], [9467, 7436, 1], [9467, 7437, 1], [9467, 7438, 1], [9467, 7439, 1], [9467, 7440, 1], [9467, 7441, 1], [9467, 7442, 1], [9467, 7443, 1], [9467, 7444, 1], [9467, 7445, 1], [9467, 7446, 1], [9467, 7447, 1], [9467, 7448, 1], [9467, 7449, 1], [9467, 7450, 1], [9467, 7451, 1], [9467, 7452, 1], [9467, 7453, 1], [9467, 7454, 1], [9467, 7455, 1], [9467, 7456, 1], [9467, 7457, 1], [9467, 7458, 1], [9467, 7459, 1], [9467, 7460, 1], [9467, 7461, 1], [9467, 7462, 1], [9467, 7463, 1], [9467, 7464, 1], [9467, 7465, 1], [9467, 7466, 1], [9467, 7467, 1], [9467, 7468, 1], [9467, 7469, 1], [9467, 7470, 1], [9467, 7471, 1], [9467, 7472, 1], [9467, 7473, 1], [9467, 7474, 1], [9467, 7475, 1], [9467, 7476, 1], [9467, 7477, 1], [9467, 7478, 1], [9467, 7479, 1], [9467, 7480, 1], [9467, 7481, 1], [9467, 7482, 1], [9467, 7483, 1], [390, 391, 1], [481, 165, 1], [1012, 1013, 1], [925, 1034, 1], [1029, 1036, 1], [982, 983, 1], [966, 967, 1], [992, 993, 1], [911, 729, 1], [729, 730, 1], [864, 865, 1], [794, 795, 1], [1005, 1038, 1], [1014, 1015, 1], [977, 9457, 1], [918, 919, 1], [188, 199, 1], [182, 183, 1], [927, 1034, 1], [986, 987, 1], [411, 337, 1], [337, 338, 1], [9469, 1016, 1], [9469, 3004, 1], [9469, 3005, 1], [9469, 3006, 1], [9469, 3007, 1], [9469, 3008, 1], [9469, 3009, 1], [9469, 3010, 1], [9469, 3011, 1], [9469, 3012, 1], [9469, 3013, 1], [9469, 3014, 1], [9469, 3015, 1], [9469, 3016, 1], [9469, 3017, 1], [9469, 3018, 1], [9469, 3019, 1], [9469, 3020, 1], [9469, 3021, 1], [9469, 3022, 1], [9469, 3023, 1], [9469, 3024, 1], [9469, 3025, 1], [9469, 3026, 1], [9469, 3027, 1], [9469, 3028, 1], [9469, 3029, 1], [9469, 3030, 1], [9469, 3031, 1], [9469, 3032, 1], [9469, 3033, 1], [9469, 3034, 1], [9469, 3035, 1], [9469, 3036, 1], [9469, 3037, 1], [9469, 3038, 1], [9469, 3039, 1], [9469, 3040, 1], [9469, 3041, 1], [9469, 3042, 1], [9469, 3043, 1], [9469, 3044, 1], [9469, 3045, 1], [9469, 3046, 1], [9469, 3047, 1], [9469, 3048, 1], [9469, 3049, 1], [9469, 3050, 1], [9469, 3051, 1], [9469, 3052, 1], [9469, 3053, 1], [9469, 3054, 1], [9469, 3055, 1], [9469, 3056, 1], [9469, 3057, 1], [9469, 3058, 1], [9469, 3059, 1], [9469, 3060, 1], [9469, 3061, 1], [9469, 3062, 1], [9469, 3063, 1], [9469, 3064, 1], [9469, 3065, 1], [9469, 3066, 1], [9469, 3067, 1], [9469, 3068, 1], [9469, 3069, 1], [9469, 3070, 1], [9469, 3071, 1], [9469, 3072, 1], [9469, 3073, 1], [9469, 3074, 1], [9469, 3075, 1], [9469, 3076, 1], [9469, 3077, 1], [9469, 3078, 1], [9469, 3079, 1], [9469, 3080, 1], [9469, 3081, 1], [9469, 3082, 1], [9469, 3083, 1], [9469, 3084, 1], [9469, 3085, 1], [9469, 3086, 1], [9469, 3087, 1], [9469, 3088, 1], [9469, 3089, 1], [9469, 3090, 1], [9469, 3091, 1], [9469, 3092, 1], [9469, 3093, 1], [9469, 3094, 1], [9469, 3095, 1], [9469, 3096, 1], [9469, 3097, 1], [9469, 3098, 1], [9469, 3099, 1], [9469, 3100, 1], [9469, 3101, 1], [9469, 3102, 1], [9469, 3103, 1], [9469, 3104, 1], [9469, 3105, 1], [9469, 3106, 1], [9469, 3107, 1], [9469, 3108, 1], [9469, 3109, 1], [9469, 3110, 1], [9469, 3111, 1], [9469, 3112, 1], [9469, 3113, 1], [9469, 3114, 1], [9469, 3115, 1], [9469, 3116, 1], [9469, 3117, 1], [9469, 3118, 1], [9469, 3119, 1], [9469, 3120, 1], [9469, 3121, 1], [9469, 3122, 1], [9469, 3123, 1], [9469, 3124, 1], [9469, 3125, 1], [9469, 3126, 1], [9469, 3127, 1], [9469, 3128, 1], [9469, 3129, 1], [9469, 3130, 1], [9469, 3131, 1], [9469, 3132, 1], [9469, 3133, 1], [9469, 3134, 1], [9469, 3135, 1], [9469, 3136, 1], [9469, 3137, 1], [9469, 3138, 1], [9469, 3139, 1], [9469, 3140, 1], [9469, 3141, 1], [9469, 3142, 1], [9469, 3143, 1], [9469, 3144, 1], [9469, 3145, 1], [9469, 3146, 1], [9469, 3147, 1], [9469, 3148, 1], [9469, 3149, 1], [9469, 3150, 1], [9469, 3151, 1], [9469, 3152, 1], [9469, 3153, 1], [9469, 3154, 1], [9469, 3155, 1], [9469, 3156, 1], [9469, 3157, 1], [9469, 3158, 1], [9469, 3159, 1], [9469, 3160, 1], [9469, 3161, 1], [9469, 3162, 1], [9469, 3163, 1], [9469, 3164, 1], [9469, 3165, 1], [9469, 3166, 1], [9469, 3167, 1], [9469, 3168, 1], [9469, 3169, 1], [9469, 3170, 1], [9469, 3171, 1], [9469, 3172, 1], [9469, 3173, 1], [9469, 3174, 1], [9469, 3175, 1], [9469, 3176, 1], [9469, 3177, 1], [9469, 3178, 1], [9469, 3179, 1], [9469, 3180, 1], [9469, 3181, 1], [9469, 3182, 1], [9469, 3183, 1], [9469, 3184, 1], [9469, 3185, 1], [9469, 3186, 1], [9469, 3187, 1], [9469, 3188, 1], [9469, 3189, 1], [9469, 3190, 1], [9469, 3191, 1], [9469, 3192, 1], [9469, 3193, 1], [9469, 3194, 1], [9469, 3195, 1], [9469, 3196, 1], [9469, 3197, 1], [9469, 3198, 1], [9469, 3199, 1], [9469, 3200, 1], [9469, 3201, 1], [9469, 3202, 1], [9469, 3203, 1], [9469, 3204, 1], [9469, 3205, 1], [9469, 3206, 1], [9469, 3207, 1], [9469, 3208, 1], [9469, 3209, 1], [9469, 3210, 1], [9469, 3211, 1], [9469, 3212, 1], [9469, 3213, 1], [9469, 3214, 1], [9469, 3215, 1], [9469, 3216, 1], [9469, 3217, 1], [9469, 3218, 1], [9469, 3219, 1], [9469, 3220, 1], [9469, 3221, 1], [9469, 3222, 1], [9469, 3223, 1], [9469, 3224, 1], [9469, 3225, 1], [9469, 3226, 1], [9469, 3227, 1], [9469, 3228, 1], [9469, 3229, 1], [9469, 3230, 1], [9469, 3231, 1], [9469, 3232, 1], [9469, 3233, 1], [9469, 3234, 1], [9469, 3235, 1], [9469, 3236, 1], [9469, 3237, 1], [9469, 3238, 1], [9469, 3239, 1], [9469, 3240, 1], [9469, 3241, 1], [9469, 3242, 1], [9469, 3243, 1], [9469, 3244, 1], [9469, 3245, 1], [9469, 3246, 1], [9469, 3247, 1], [9469, 3248, 1], [9469, 3249, 1], [9469, 3250, 1], [9469, 3251, 1], [9469, 3252, 1], [9469, 3253, 1], [9469, 3254, 1], [9469, 3255, 1], [9469, 3256, 1], [9469, 3257, 1], [9469, 3258, 1], [9469, 3259, 1], [9469, 3260, 1], [9469, 3261, 1], [9469, 3262, 1], [9469, 3263, 1], [9469, 3264, 1], [9469, 3265, 1], [9469, 3266, 1], [9469, 3267, 1], [9469, 3268, 1], [9469, 3269, 1], [9469, 3270, 1], [9469, 3271, 1], [9469, 3272, 1], [9469, 3273, 1], [9469, 3274, 1], [9469, 3275, 1], [9469, 3276, 1], [9469, 3277, 1], [9469, 3278, 1], [9469, 3279, 1], [9469, 3280, 1], [9469, 3281, 1], [9469, 3282, 1], [9469, 3283, 1], [1016, 1017, 1], [933, 9466, 1], [194, 292, 1], [494, 495, 1], [919, 1034, 1], [575, 893, 1], [893, 894, 1], [954, 955, 1], [9471, 1024, 1], [9471, 5524, 1], [9471, 5525, 1], [9471, 5526, 1], [9471, 5527, 1], [9471, 5528, 1], [9471, 5529, 1], [9471, 5530, 1], [9471, 5531, 1], [9471, 5532, 1], [9471, 5533, 1], [9471, 5534, 1], [9471, 5535, 1], [9471, 5536, 1], [9471, 5537, 1], [9471, 5538, 1], [9471, 5539, 1], [9471, 5540, 1], [9471, 5541, 1], [9471, 5542, 1], [9471, 5543, 1], [9471, 5544, 1], [9471, 5545, 1], [9471, 5546, 1], [9471, 5547, 1], [9471, 5548, 1], [9471, 5549, 1], [9471, 5550, 1], [9471, 5551, 1], [9471, 5552, 1], [9471, 5553, 1], [9471, 5554, 1], [9471, 5555, 1], [9471, 5556, 1], [9471, 5557, 1], [9471, 5558, 1], [9471, 5559, 1], [9471, 5560, 1], [9471, 5561, 1], [9471, 5562, 1], [9471, 5563, 1], [9471, 5564, 1], [9471, 5565, 1], [9471, 5566, 1], [9471, 5567, 1], [9471, 5568, 1], [9471, 5569, 1], [9471, 5570, 1], [9471, 5571, 1], [9471, 5572, 1], [9471, 5573, 1], [9471, 5574, 1], [9471, 5575, 1], [9471, 5576, 1], [9471, 5577, 1], [9471, 5578, 1], [9471, 5579, 1], [9471, 5580, 1], [9471, 5581, 1], [9471, 5582, 1], [9471, 5583, 1], [9471, 5584, 1], [9471, 5585, 1], [9471, 5586, 1], [9471, 5587, 1], [9471, 5588, 1], [9471, 5589, 1], [9471, 5590, 1], [9471, 5591, 1], [9471, 5592, 1], [9471, 5593, 1], [9471, 5594, 1], [9471, 5595, 1], [9471, 5596, 1], [9471, 5597, 1], [9471, 5598, 1], [9471, 5599, 1], [9471, 5600, 1], [9471, 5601, 1], [9471, 5602, 1], [9471, 5603, 1], [9471, 5604, 1], [9471, 5605, 1], [9471, 5606, 1], [9471, 5607, 1], [9471, 5608, 1], [9471, 5609, 1], [9471, 5610, 1], [9471, 5611, 1], [9471, 5612, 1], [9471, 5613, 1], [9471, 5614, 1], [9471, 5615, 1], [9471, 5616, 1], [9471, 5617, 1], [9471, 5618, 1], [9471, 5619, 1], [9471, 5620, 1], [9471, 5621, 1], [9471, 5622, 1], [9471, 5623, 1], [9471, 5624, 1], [9471, 5625, 1], [9471, 5626, 1], [9471, 5627, 1], [9471, 5628, 1], [9471, 5629, 1], [9471, 5630, 1], [9471, 5631, 1], [9471, 5632, 1], [9471, 5633, 1], [9471, 5634, 1], [9471, 5635, 1], [9471, 5636, 1], [9471, 5637, 1], [9471, 5638, 1], [9471, 5639, 1], [9471, 5640, 1], [9471, 5641, 1], [9471, 5642, 1], [9471, 5643, 1], [9471, 5644, 1], [9471, 5645, 1], [9471, 5646, 1], [9471, 5647, 1], [9471, 5648, 1], [9471, 5649, 1], [9471, 5650, 1], [9471, 5651, 1], [9471, 5652, 1], [9471, 5653, 1], [9471, 5654, 1], [9471, 5655, 1], [9471, 5656, 1], [9471, 5657, 1], [9471, 5658, 1], [9471, 5659, 1], [9471, 5660, 1], [9471, 5661, 1], [9471, 5662, 1], [9471, 5663, 1], [9471, 5664, 1], [9471, 5665, 1], [9471, 5666, 1], [9471, 5667, 1], [9471, 5668, 1], [9471, 5669, 1], [9471, 5670, 1], [9471, 5671, 1], [9471, 5672, 1], [9471, 5673, 1], [9471, 5674, 1], [9471, 5675, 1], [9471, 5676, 1], [9471, 5677, 1], [9471, 5678, 1], [9471, 5679, 1], [9471, 5680, 1], [9471, 5681, 1], [9471, 5682, 1], [9471, 5683, 1], [9471, 5684, 1], [9471, 5685, 1], [9471, 5686, 1], [9471, 5687, 1], [9471, 5688, 1], [9471, 5689, 1], [9471, 5690, 1], [9471, 5691, 1], [9471, 5692, 1], [9471, 5693, 1], [9471, 5694, 1], [9471, 5695, 1], [9471, 5696, 1], [9471, 5697, 1], [9471, 5698, 1], [9471, 5699, 1], [9471, 5700, 1], [9471, 5701, 1], [9471, 5702, 1], [9471, 5703, 1], [9471, 5704, 1], [9471, 5705, 1], [9471, 5706, 1], [9471, 5707, 1], [9471, 5708, 1], [9471, 5709, 1], [9471, 5710, 1], [9471, 5711, 1], [9471, 5712, 1], [9471, 5713, 1], [9471, 5714, 1], [9471, 5715, 1], [9471, 5716, 1], [9471, 5717, 1], [9471, 5718, 1], [9471, 5719, 1], [9471, 5720, 1], [9471, 5721, 1], [9471, 5722, 1], [9471, 5723, 1], [9471, 5724, 1], [9471, 5725, 1], [9471, 5726, 1], [9471, 5727, 1], [9471, 5728, 1], [9471, 5729, 1], [9471, 5730, 1], [9471, 5731, 1], [9471, 5732, 1], [9471, 5733, 1], [9471, 5734, 1], [9471, 5735, 1], [9471, 5736, 1], [9471, 5737, 1], [9471, 5738, 1], [9471, 5739, 1], [9471, 5740, 1], [9471, 5741, 1], [9471, 5742, 1], [9471, 5743, 1], [9471, 5744, 1], [9471, 5745, 1], [9471, 5746, 1], [9471, 5747, 1], [9471, 5748, 1], [9471, 5749, 1], [9471, 5750, 1], [9471, 5751, 1], [9471, 5752, 1], [9471, 5753, 1], [9471, 5754, 1], [9471, 5755, 1], [9471, 5756, 1], [9471, 5757, 1], [9471, 5758, 1], [9471, 5759, 1], [9471, 5760, 1], [9471, 5761, 1], [9471, 5762, 1], [9471, 5763, 1], [9471, 5764, 1], [9471, 5765, 1], [9471, 5766, 1], [9471, 5767, 1], [9471, 5768, 1], [9471, 5769, 1], [9471, 5770, 1], [9471, 5771, 1], [9471, 5772, 1], [9471, 5773, 1], [9471, 5774, 1], [9471, 5775, 1], [9471, 5776, 1], [9471, 5777, 1], [9471, 5778, 1], [9471, 5779, 1], [9471, 5780, 1], [9471, 5781, 1], [9471, 5782, 1], [9471, 5783, 1], [9471, 5784, 1], [9471, 5785, 1], [9471, 5786, 1], [9471, 5787, 1], [9471, 5788, 1], [9471, 5789, 1], [9471, 5790, 1], [9471, 5791, 1], [9471, 5792, 1], [9471, 5793, 1], [9471, 5794, 1], [9471, 5795, 1], [9471, 5796, 1], [9471, 5797, 1], [9471, 5798, 1], [9471, 5799, 1], [9471, 5800, 1], [9471, 5801, 1], [9471, 5802, 1], [9471, 5803, 1], [1024, 1025, 1], [958, 959, 1], [141, 478, 1], [141, 413, 1], [478, 479, 1], [581, 877, 1], [877, 878, 1], [937, 9471, 1], [988, 989, 1], [943, 9469, 1], [1018, 1019, 1], [698, 699, 1], [891, 59, 1], [1021, 1036, 1], [1028, 1029, 1], [1000, 1001, 1], [356, 357, 1], [1011, 1038, 1], [1003, 1038, 1], [576, 577, 1], [164, 860, 1], [860, 861, 1], [1013, 1036, 1], [994, 995, 1], [765, 766, 1], [985, 9454, 1], [365, 610, 1], [917, 1034, 1], [991, 9459, 1], [346, 347, 1], [945, 9464, 1], [413, 414, 1], [1010, 1011, 1], [952, 953, 1], [989, 9460, 1], [995, 1038, 1], [513, 514, 1], [314, 315, 1], [1, 2, 1], [2, 3, 1], [3, 4, 1], [6, 7, 1], [7, 8, 1], [8, 9, 1], [9, 10, 1], [10, 11, 1], [11, 12, 1], [14, 15, 1], [15, 16, 1], [16, 17, 1], [17, 18, 1], [18, 19, 1], [19, 20, 1], [20, 21, 1], [21, 22, 1], [22, 23, 1], [23, 24, 1], [24, 25, 1], [25, 26, 1], [26, 27, 1], [27, 28, 1], [28, 29, 1], [29, 30, 1], [30, 31, 1], [31, 32, 1], [32, 33, 1], [33, 34, 1], [34, 35, 1], [35, 36, 1], [36, 37, 1], [37, 38, 1], [38, 39, 1], [39, 40, 1], [40, 41, 1], [41, 42, 1], [42, 43, 1], [43, 44, 1], [44, 45, 1], [45, 46, 1], [46, 47, 1], [47, 48, 1], [48, 49, 1], [51, 52, 1], [52, 53, 1], [53, 54, 1], [54, 55, 1], [55, 56, 1], [56, 57, 1], [57, 58, 1], [61, 62, 1], [62, 63, 1], [63, 64, 1], [64, 65, 1], [65, 66, 1], [66, 67, 1], [67, 68, 1], [68, 69, 1], [69, 70, 1], [70, 71, 1], [71, 72, 1], [72, 73, 1], [73, 74, 1], [74, 75, 1], [75, 76, 1], [76, 77, 1], [77, 78, 1], [78, 79, 1], [79, 80, 1], [80, 81, 1], [81, 82, 1], [82, 83, 1], [83, 84, 1], [84, 85, 1], [85, 86, 1], [86, 87, 1], [87, 88, 1], [88, 89, 1], [89, 90, 1], [90, 91, 1], [91, 92, 1], [92, 93, 1], [93, 94, 1], [94, 95, 1], [95, 96, 1], [96, 97, 1], [97, 98, 1], [98, 99, 1], [99, 100, 1], [100, 101, 1], [101, 102, 1], [102, 103, 1], [103, 104, 1], [104, 105, 1], [105, 106, 1], [106, 107, 1], [107, 108, 1], [108, 109, 1], [109, 110, 1], [110, 111, 1], [111, 112, 1], [112, 113, 1], [113, 114, 1], [114, 115, 1], [115, 116, 1], [116, 117, 1], [117, 118, 1], [118, 119, 1], [119, 120, 1], [120, 121, 1], [121, 122, 1], [122, 123, 1], [123, 124, 1], [124, 125, 1], [125, 126, 1], [126, 127, 1], [129, 130, 1], [130, 131, 1], [131, 132, 1], [132, 133, 1], [133, 134, 1], [134, 135, 1], [135, 136, 1], [136, 137, 1], [137, 138, 1], [138, 139, 1], [139, 140, 1], [143, 144, 1], [144, 145, 1], [145, 146, 1], [146, 147, 1], [148, 149, 1], [149, 150, 1], [150, 151, 1], [151, 152, 1], [152, 153, 1], [155, 156, 1], [159, 160, 1], [160, 161, 1], [161, 162, 1], [162, 163, 1], [163, 164, 1], [166, 167, 1], [167, 168, 1], [168, 169, 1], [169, 170, 1], [170, 171, 1], [171, 172, 1], [172, 173, 1], [173, 174, 1], [177, 178, 1], [178, 179, 1], [179, 180, 1], [180, 181, 1], [183, 184, 1], [184, 185, 1], [185, 186, 1], [186, 187, 1], [190, 191, 1], [191, 192, 1], [192, 193, 1], [193, 194, 1], [196, 197, 1], [197, 198, 1], [201, 202, 1], [202, 203, 1], [203, 204, 1], [204, 205, 1], [205, 206, 1], [206, 207, 1], [207, 208, 1], [208, 209, 1], [209, 210, 1], [210, 211, 1], [211, 212, 1], [212, 213, 1], [213, 214, 1], [214, 215, 1], [215, 216, 1], [216, 217, 1], [217, 218, 1], [218, 219, 1], [220, 221, 1], [221, 222, 1], [222, 223, 1], [223, 224, 1], [224, 225, 1], [225, 226, 1], [227, 228, 1], [228, 229, 1], [229, 230, 1], [230, 231, 1], [231, 232, 1], [232, 233, 1], [233, 234, 1], [234, 235, 1], [238, 239, 1], [239, 240, 1], [242, 243, 1], [243, 244, 1], [244, 245, 1], [246, 247, 1], [247, 248, 1], [248, 249, 1], [249, 250, 1], [250, 251, 1], [251, 252, 1], [252, 253, 1], [253, 254, 1], [254, 255, 1], [255, 256, 1], [256, 257, 1], [257, 258, 1], [258, 259, 1], [259, 260, 1], [260, 261, 1], [261, 262, 1], [262, 263, 1], [263, 264, 1], [264, 265, 1], [265, 266, 1], [266, 267, 1], [267, 268, 1], [268, 269, 1], [269, 270, 1], [270, 271, 1], [271, 272, 1], [272, 273, 1], [273, 274, 1], [274, 275, 1], [275, 276, 1], [276, 277, 1], [279, 280, 1], [280, 281, 1], [281, 282, 1], [282, 283, 1], [283, 284, 1], [284, 285, 1], [285, 286, 1], [286, 287, 1], [287, 288, 1], [288, 289, 1], [294, 295, 1], [295, 296, 1], [296, 297, 1], [297, 298, 1], [298, 299, 1], [299, 300, 1], [300, 301, 1], [302, 303, 1], [303, 304, 1], [304, 305, 1], [305, 306, 1], [306, 307, 1], [307, 308, 1], [308, 309, 1], [309, 310, 1], [310, 311, 1], [311, 312, 1], [312, 313, 1], [315, 316, 1], [316, 317, 1], [317, 318, 1], [318, 319, 1], [323, 324, 1], [325, 326, 1], [326, 327, 1], [327, 328, 1], [328, 329, 1], [329, 330, 1], [330, 331, 1], [331, 332, 1], [332, 333, 1], [333, 334, 1], [334, 335, 1], [335, 336, 1], [338, 339, 1], [339, 340, 1], [340, 341, 1], [341, 342, 1], [342, 343, 1], [343, 344, 1], [344, 345, 1], [347, 348, 1], [348, 349, 1], [349, 350, 1], [350, 351, 1], [351, 352, 1], [352, 353, 1], [353, 354, 1], [357, 358, 1], [359, 360, 1], [360, 361, 1], [361, 362, 1], [362, 363, 1], [363, 364, 1], [366, 367, 1], [367, 368, 1], [368, 369, 1], [369, 370, 1], [370, 371, 1], [371, 372, 1], [372, 373, 1], [373, 374, 1], [374, 375, 1], [375, 376, 1], [376, 377, 1], [377, 378, 1], [378, 379, 1], [379, 380, 1], [380, 381, 1], [381, 382, 1], [382, 383, 1], [383, 384, 1], [384, 385, 1], [385, 386, 1], [386, 387, 1], [387, 388, 1], [388, 389, 1], [391, 392, 1], [392, 393, 1], [393, 394, 1], [394, 395, 1], [398, 399, 1], [399, 400, 1], [400, 401, 1], [401, 402, 1], [404, 405, 1], [405, 406, 1], [409, 410, 1], [410, 411, 1], [414, 415, 1], [415, 416, 1], [416, 417, 1], [417, 418, 1], [418, 419, 1], [419, 420, 1], [420, 421, 1], [423, 424, 1], [426, 427, 1], [427, 428, 1], [428, 429, 1], [429, 430, 1], [430, 431, 1], [431, 432, 1], [432, 433, 1], [433, 434, 1], [434, 435, 1], [435, 436, 1], [436, 437, 1], [437, 438, 1], [438, 439, 1], [439, 440, 1], [440, 441, 1], [441, 442, 1], [442, 443, 1], [443, 444, 1], [444, 445, 1], [445, 446, 1], [446, 447, 1], [447, 448, 1], [452, 453, 1], [453, 454, 1], [454, 455, 1], [455, 456, 1], [456, 457, 1], [457, 458, 1], [458, 459, 1], [460, 461, 1], [461, 462, 1], [462, 463, 1], [463, 464, 1], [464, 465, 1], [465, 466, 1], [466, 467, 1], [467, 468, 1], [468, 469, 1], [469, 470, 1], [470, 471, 1], [471, 472, 1], [472, 473, 1], [473, 474, 1], [476, 477, 1], [479, 480, 1], [480, 481, 1], [483, 484, 1], [484, 485, 1], [485, 486, 1], [486, 487, 1], [487, 488, 1], [488, 489, 1], [489, 490, 1], [490, 491, 1], [491, 492, 1], [492, 493, 1], [495, 496, 1], [496, 497, 1], [497, 498, 1], [498, 499, 1], [501, 502, 1], [502, 503, 1], [503, 504, 1], [504, 505, 1], [505, 506, 1], [506, 507, 1], [507, 508, 1], [508, 509, 1], [509, 510, 1], [510, 511, 1], [511, 512, 1], [514, 515, 1], [515, 516, 1], [516, 517, 1], [517, 518, 1], [519, 520, 1], [520, 521, 1], [521, 522, 1], [522, 523, 1], [523, 524, 1], [524, 525, 1], [525, 526, 1], [526, 527, 1], [527, 528, 1], [528, 529, 1], [529, 530, 1], [530, 531, 1], [531, 532, 1], [532, 533, 1], [533, 534, 1], [534, 535, 1], [535, 536, 1], [536, 537, 1], [537, 538, 1], [538, 539, 1], [539, 540, 1], [540, 541, 1], [541, 542, 1], [542, 543, 1], [543, 544, 1], [544, 545, 1], [545, 546, 1], [546, 547, 1], [547, 548, 1], [548, 549, 1], [551, 552, 1], [552, 553, 1], [553, 554, 1], [554, 555, 1], [555, 556, 1], [556, 557, 1], [557, 558, 1], [559, 560, 1], [562, 563, 1], [563, 564, 1], [564, 565, 1], [565, 566, 1], [567, 568, 1], [568, 569, 1], [569, 570, 1], [570, 571, 1], [571, 572, 1], [572, 573, 1], [573, 574, 1], [574, 575, 1], [577, 578, 1], [579, 580, 1], [580, 581, 1], [582, 583, 1], [583, 584, 1], [584, 585, 1], [585, 586, 1], [586, 587, 1], [587, 588, 1], [588, 589, 1], [589, 590, 1], [590, 591, 1], [591, 592, 1], [592, 593, 1], [593, 594, 1], [594, 595, 1], [595, 596, 1], [596, 597, 1], [597, 598, 1], [598, 599, 1], [599, 600, 1], [600, 601, 1], [601, 602, 1], [602, 603, 1], [603, 604, 1], [604, 605, 1], [607, 608, 1], [608, 609, 1], [612, 613, 1], [613, 614, 1], [614, 615, 1], [615, 616, 1], [618, 619, 1], [619, 620, 1], [622, 623, 1], [623, 624, 1], [624, 625, 1], [625, 626, 1], [626, 627, 1], [627, 628, 1], [628, 629, 1], [629, 630, 1], [630, 631, 1], [631, 632, 1], [632, 633, 1], [633, 634, 1], [634, 635, 1], [635, 636, 1], [636, 637, 1], [637, 638, 1], [638, 639, 1], [639, 640, 1], [640, 641, 1], [641, 642, 1], [642, 643, 1], [643, 644, 1], [644, 645, 1], [645, 646, 1], [646, 647, 1], [647, 648, 1], [648, 649, 1], [649, 650, 1], [650, 651, 1], [651, 652, 1], [653, 654, 1], [654, 655, 1], [655, 656, 1], [656, 657, 1], [657, 658, 1], [658, 659, 1], [659, 660, 1], [660, 661, 1], [662, 663, 1], [663, 664, 1], [664, 665, 1], [665, 666, 1], [666, 667, 1], [667, 668, 1], [668, 669, 1], [669, 670, 1], [670, 671, 1], [671, 672, 1], [672, 673, 1], [673, 674, 1], [674, 675, 1], [675, 676, 1], [676, 677, 1], [677, 678, 1], [678, 679, 1], [679, 680, 1], [680, 681, 1], [681, 682, 1], [682, 683, 1], [683, 684, 1], [684, 685, 1], [686, 687, 1], [687, 688, 1], [688, 689, 1], [689, 690, 1], [690, 691, 1], [691, 692, 1], [692, 693, 1], [693, 694, 1], [694, 695, 1], [695, 696, 1], [696, 697, 1], [699, 700, 1], [700, 701, 1], [701, 702, 1], [702, 703, 1], [703, 704, 1], [704, 705, 1], [705, 706, 1], [706, 707, 1], [707, 708, 1], [708, 709, 1], [709, 710, 1], [710, 711, 1], [711, 712, 1], [712, 713, 1], [713, 714, 1], [714, 715, 1], [715, 716, 1], [716, 717, 1], [717, 718, 1], [718, 719, 1], [719, 720, 1], [720, 721, 1], [724, 725, 1], [725, 726, 1], [726, 727, 1], [727, 728, 1], [730, 731, 1], [731, 732, 1], [732, 733, 1], [733, 734, 1], [734, 735, 1], [735, 736, 1], [736, 737, 1], [737, 738, 1], [738, 739, 1], [739, 740, 1], [740, 741, 1], [741, 742, 1], [742, 743, 1], [743, 744, 1], [744, 745, 1], [745, 746, 1], [747, 748, 1], [748, 749, 1], [751, 752, 1], [753, 754, 1], [754, 755, 1], [755, 756, 1], [756, 757, 1], [757, 758, 1], [758, 759, 1], [759, 760, 1], [760, 761, 1], [761, 762, 1], [762, 763, 1], [763, 764, 1], [766, 767, 1], [767, 768, 1], [768, 769, 1], [769, 770, 1], [771, 772, 1], [772, 773, 1], [774, 775, 1], [775, 776, 1], [776, 777, 1], [777, 778, 1], [778, 779, 1], [781, 782, 1], [782, 783, 1], [783, 784, 1], [784, 785, 1], [786, 787, 1], [787, 788, 1], [791, 792, 1], [792, 793, 1], [795, 796, 1], [796, 797, 1], [797, 798, 1], [798, 799, 1], [799, 800, 1], [800, 801, 1], [801, 802, 1], [803, 804, 1], [804, 805, 1], [805, 806, 1], [806, 807, 1], [807, 808, 1], [808, 809, 1], [809, 810, 1], [810, 811, 1], [811, 812, 1], [812, 813, 1], [813, 814, 1], [815, 816, 1], [816, 817, 1], [817, 818, 1], [818, 819, 1], [819, 820, 1], [820, 821, 1], [821, 822, 1], [822, 823, 1], [823, 824, 1], [824, 825, 1], [825, 826, 1], [826, 827, 1], [827, 828, 1], [828, 829, 1], [829, 830, 1], [830, 831, 1], [831, 832, 1], [832, 833, 1], [833, 834, 1], [834, 835, 1], [835, 836, 1], [836, 837, 1], [837, 838, 1], [840, 841, 1], [841, 842, 1], [842, 843, 1], [843, 844, 1], [846, 847, 1], [848, 849, 1], [849, 850, 1], [850, 851, 1], [851, 852, 1], [852, 853, 1], [853, 854, 1], [854, 855, 1], [855, 856, 1], [856, 857, 1], [857, 858, 1], [858, 859, 1], [861, 862, 1], [865, 866, 1], [866, 867, 1], [867, 868, 1], [868, 869, 1], [869, 870, 1], [870, 871, 1], [871, 872, 1], [872, 873, 1], [873, 874, 1], [874, 875, 1], [878, 879, 1], [879, 880, 1], [880, 881, 1], [881, 882, 1], [882, 883, 1], [883, 884, 1], [884, 885, 1], [887, 888, 1], [888, 889, 1], [889, 890, 1], [890, 891, 1], [894, 895, 1], [897, 898, 1], [898, 899, 1], [899, 900, 1], [900, 901, 1], [901, 902, 1], [902, 903, 1], [903, 904, 1], [904, 905, 1], [905, 906, 1], [906, 907, 1], [907, 908, 1], [908, 909, 1], [909, 910, 1], [910, 911, 1], [1032, 1033, 1], [1040, 1041, 1], [1042, 1043, 1], [1044, 9463, 1], [1045, 9463, 1], [1046, 9463, 1], [1047, 9463, 1], [1048, 9463, 1], [1049, 9463, 1], [1050, 9463, 1], [1051, 9463, 1], [1052, 9463, 1], [1053, 9463, 1], [1054, 9463, 1], [1055, 9463, 1], [1056, 9463, 1], [1057, 9463, 1], [1058, 9463, 1], [1059, 9463, 1], [1060, 9463, 1], [1061, 9463, 1], [1062, 9463, 1], [1063, 9463, 1], [1064, 9463, 1], [1065, 9463, 1], [1066, 9463, 1], [1067, 9463, 1], [1068, 9463, 1], [1069, 9463, 1], [1070, 9463, 1], [1071, 9463, 1], [1072, 9463, 1], [1073, 9463, 1], [1074, 9463, 1], [1075, 9463, 1], [1076, 9463, 1], [1077, 9463, 1], [1078, 9463, 1], [1079, 9463, 1], [1080, 9463, 1], [1081, 9463, 1], [1082, 9463, 1], [1083, 9463, 1], [1084, 9463, 1], [1085, 9463, 1], [1086, 9463, 1], [1087, 9463, 1], [1088, 9463, 1], [1089, 9463, 1], [1090, 9463, 1], [1091, 9463, 1], [1092, 9463, 1], [1093, 9463, 1], [1094, 9463, 1], [1095, 9463, 1], [1096, 9463, 1], [1097, 9463, 1], [1098, 9463, 1], [1099, 9463, 1], [1100, 9463, 1], [1101, 9463, 1], [1102, 9463, 1], [1103, 9463, 1], [1104, 9463, 1], [1105, 9463, 1], [1106, 9463, 1], [1107, 9463, 1], [1108, 9463, 1], [1109, 9463, 1], [1110, 9463, 1], [1111, 9463, 1], [1112, 9463, 1], [1113, 9463, 1], [1114, 9463, 1], [1115, 9463, 1], [1116, 9463, 1], [1117, 9463, 1], [1118, 9463, 1], [1119, 9463, 1], [1120, 9463, 1], [1121, 9463, 1], [1122, 9463, 1], [1123, 9463, 1], [1124, 9463, 1], [1125, 9463, 1], [1126, 9463, 1], [1127, 9463, 1], [1128, 9463, 1], [1129, 9463, 1], [1130, 9463, 1], [1131, 9463, 1], [1132, 9463, 1], [1133, 9463, 1], [1134, 9463, 1], [1135, 9463, 1], [1136, 9463, 1], [1137, 9463, 1], [1138, 9463, 1], [1139, 9463, 1], [1140, 9463, 1], [1141, 9463, 1], [1142, 9463, 1], [1143, 9463, 1], [1144, 9463, 1], [1145, 9463, 1], [1146, 9463, 1], [1147, 9463, 1], [1148, 9463, 1], [1149, 9463, 1], [1150, 9463, 1], [1151, 9463, 1], [1152, 9463, 1], [1153, 9463, 1], [1154, 9463, 1], [1155, 9463, 1], [1156, 9463, 1], [1157, 9463, 1], [1158, 9463, 1], [1159, 9463, 1], [1160, 9463, 1], [1161, 9463, 1], [1162, 9463, 1], [1163, 9463, 1], [1164, 9463, 1], [1165, 9463, 1], [1166, 9463, 1], [1167, 9463, 1], [1168, 9463, 1], [1169, 9463, 1], [1170, 9463, 1], [1171, 9463, 1], [1172, 9463, 1], [1173, 9463, 1], [1174, 9463, 1], [1175, 9463, 1], [1176, 9463, 1], [1177, 9463, 1], [1178, 9463, 1], [1179, 9463, 1], [1180, 9463, 1], [1181, 9463, 1], [1182, 9463, 1], [1183, 9463, 1], [1184, 9444, 1], [1185, 9444, 1], [1186, 9444, 1], [1187, 9444, 1], [1188, 9444, 1], [1189, 9444, 1], [1190, 9444, 1], [1191, 9444, 1], [1192, 9444, 1], [1193, 9444, 1], [1194, 9444, 1], [1195, 9444, 1], [1196, 9444, 1], [1197, 9444, 1], [1198, 9444, 1], [1199, 9444, 1], [1200, 9444, 1], [1201, 9444, 1], [1202, 9444, 1], [1203, 9444, 1], [1204, 9444, 1], [1205, 9444, 1], [1206, 9444, 1], [1207, 9444, 1], [1208, 9444, 1], [1209, 9444, 1], [1210, 9444, 1], [1211, 9444, 1], [1212, 9444, 1], [1213, 9444, 1], [1214, 9444, 1], [1215, 9444, 1], [1216, 9444, 1], [1217, 9444, 1], [1218, 9444, 1], [1219, 9444, 1], [1220, 9444, 1], [1221, 9444, 1], [1222, 9444, 1], [1223, 9444, 1], [1224, 9444, 1], [1225, 9444, 1], [1226, 9444, 1], [1227, 9444, 1], [1228, 9444, 1], [1229, 9444, 1], [1230, 9444, 1], [1231, 9444, 1], [1232, 9444, 1], [1233, 9444, 1], [1234, 9444, 1], [1235, 9444, 1], [1236, 9444, 1], [1237, 9444, 1], [1238, 9444, 1], [1239, 9444, 1], [1240, 9444, 1], [1241, 9444, 1], [1242, 9444, 1], [1243, 9444, 1], [1244, 9444, 1], [1245, 9444, 1], [1246, 9444, 1], [1247, 9444, 1], [1248, 9444, 1], [1249, 9444, 1], [1250, 9444, 1], [1251, 9444, 1], [1252, 9444, 1], [1253, 9444, 1], [1254, 9444, 1], [1255, 9444, 1], [1256, 9444, 1], [1257, 9444, 1], [1258, 9444, 1], [1259, 9444, 1], [1260, 9444, 1], [1261, 9444, 1], [1262, 9444, 1], [1263, 9444, 1], [1264, 9444, 1], [1265, 9444, 1], [1266, 9444, 1], [1267, 9444, 1], [1268, 9444, 1], [1269, 9444, 1], [1270, 9444, 1], [1271, 9444, 1], [1272, 9444, 1], [1273, 9444, 1], [1274, 9444, 1], [1275, 9444, 1], [1276, 9444, 1], [1277, 9444, 1], [1278, 9444, 1], [1279, 9444, 1], [1280, 9444, 1], [1281, 9444, 1], [1282, 9444, 1], [1283, 9444, 1], [1284, 9444, 1], [1285, 9444, 1], [1286, 9444, 1], [1287, 9444, 1], [1288, 9444, 1], [1289, 9444, 1], [1290, 9444, 1], [1291, 9444, 1], [1292, 9444, 1], [1293, 9444, 1], [1294, 9444, 1], [1295, 9444, 1], [1296, 9444, 1], [1297, 9444, 1], [1298, 9444, 1], [1299, 9444, 1], [1300, 9444, 1], [1301, 9444, 1], [1302, 9444, 1], [1303, 9444, 1], [1304, 9444, 1], [1305, 9444, 1], [1306, 9444, 1], [1307, 9444, 1], [1308, 9444, 1], [1309, 9444, 1], [1310, 9444, 1], [1311, 9444, 1], [1312, 9444, 1], [1313, 9444, 1], [1314, 9444, 1], [1315, 9444, 1], [1316, 9444, 1], [1317, 9444, 1], [1318, 9444, 1], [1319, 9444, 1], [1320, 9444, 1], [1321, 9444, 1], [1322, 9444, 1], [1323, 9444, 1], [1324, 9468, 1], [1325, 9468, 1], [1326, 9468, 1], [1327, 9468, 1], [1328, 9468, 1], [1329, 9468, 1], [1330, 9468, 1], [1331, 9468, 1], [1332, 9468, 1], [1333, 9468, 1], [1334, 9468, 1], [1335, 9468, 1], [1336, 9468, 1], [1337, 9468, 1], [1338, 9468, 1], [1339, 9468, 1], [1340, 9468, 1], [1341, 9468, 1], [1342, 9468, 1], [1343, 9468, 1], [1344, 9468, 1], [1345, 9468, 1], [1346, 9468, 1], [1347, 9468, 1], [1348, 9468, 1], [1349, 9468, 1], [1350, 9468, 1], [1351, 9468, 1], [1352, 9468, 1], [1353, 9468, 1], [1354, 9468, 1], [1355, 9468, 1], [1356, 9468, 1], [1357, 9468, 1], [1358, 9468, 1], [1359, 9468, 1], [1360, 9468, 1], [1361, 9468, 1], [1362, 9468, 1], [1363, 9468, 1], [1364, 9468, 1], [1365, 9468, 1], [1366, 9468, 1], [1367, 9468, 1], [1368, 9468, 1], [1369, 9468, 1], [1370, 9468, 1], [1371, 9468, 1], [1372, 9468, 1], [1373, 9468, 1], [1374, 9468, 1], [1375, 9468, 1], [1376, 9468, 1], [1377, 9468, 1], [1378, 9468, 1], [1379, 9468, 1], [1380, 9468, 1], [1381, 9468, 1], [1382, 9468, 1], [1383, 9468, 1], [1384, 9468, 1], [1385, 9468, 1], [1386, 9468, 1], [1387, 9468, 1], [1388, 9468, 1], [1389, 9468, 1], [1390, 9468, 1], [1391, 9468, 1], [1392, 9468, 1], [1393, 9468, 1], [1394, 9468, 1], [1395, 9468, 1], [1396, 9468, 1], [1397, 9468, 1], [1398, 9468, 1], [1399, 9468, 1], [1400, 9468, 1], [1401, 9468, 1], [1402, 9468, 1], [1403, 9468, 1], [1404, 9468, 1], [1405, 9468, 1], [1406, 9468, 1], [1407, 9468, 1], [1408, 9468, 1], [1409, 9468, 1], [1410, 9468, 1], [1411, 9468, 1], [1412, 9468, 1], [1413, 9468, 1], [1414, 9468, 1], [1415, 9468, 1], [1416, 9468, 1], [1417, 9468, 1], [1418, 9468, 1], [1419, 9468, 1], [1420, 9468, 1], [1421, 9468, 1], [1422, 9468, 1], [1423, 9468, 1], [1424, 9468, 1], [1425, 9468, 1], [1426, 9468, 1], [1427, 9468, 1], [1428, 9468, 1], [1429, 9468, 1], [1430, 9468, 1], [1431, 9468, 1], [1432, 9468, 1], [1433, 9468, 1], [1434, 9468, 1], [1435, 9468, 1], [1436, 9468, 1], [1437, 9468, 1], [1438, 9468, 1], [1439, 9468, 1], [1440, 9468, 1], [1441, 9468, 1], [1442, 9468, 1], [1443, 9468, 1], [1444, 9468, 1], [1445, 9468, 1], [1446, 9468, 1], [1447, 9468, 1], [1448, 9468, 1], [1449, 9468, 1], [1450, 9468, 1], [1451, 9468, 1], [1452, 9468, 1], [1453, 9468, 1], [1454, 9468, 1], [1455, 9468, 1], [1456, 9468, 1], [1457, 9468, 1], [1458, 9468, 1], [1459, 9468, 1], [1460, 9468, 1], [1461, 9468, 1], [1462, 9468, 1], [1463, 9468, 1], [1464, 9468, 1], [1465, 9468, 1], [1466, 9468, 1], [1467, 9468, 1], [1468, 9468, 1], [1469, 9468, 1], [1470, 9468, 1], [1471, 9468, 1], [1472, 9468, 1], [1473, 9468, 1], [1474, 9468, 1], [1475, 9468, 1], [1476, 9468, 1], [1477, 9468, 1], [1478, 9468, 1], [1479, 9468, 1], [1480, 9468, 1], [1481, 9468, 1], [1482, 9468, 1], [1483, 9468, 1], [1484, 9468, 1], [1485, 9468, 1], [1486, 9468, 1], [1487, 9468, 1], [1488, 9468, 1], [1489, 9468, 1], [1490, 9468, 1], [1491, 9468, 1], [1492, 9468, 1], [1493, 9468, 1], [1494, 9468, 1], [1495, 9468, 1], [1496, 9468, 1], [1497, 9468, 1], [1498, 9468, 1], [1499, 9468, 1], [1500, 9468, 1], [1501, 9468, 1], [1502, 9468, 1], [1503, 9468, 1], [1504, 9468, 1], [1505, 9468, 1], [1506, 9468, 1], [1507, 9468, 1], [1508, 9468, 1], [1509, 9468, 1], [1510, 9468, 1], [1511, 9468, 1], [1512, 9468, 1], [1513, 9468, 1], [1514, 9468, 1], [1515, 9468, 1], [1516, 9468, 1], [1517, 9468, 1], [1518, 9468, 1], [1519, 9468, 1], [1520, 9468, 1], [1521, 9468, 1], [1522, 9468, 1], [1523, 9468, 1], [1524, 9468, 1], [1525, 9468, 1], [1526, 9468, 1], [1527, 9468, 1], [1528, 9468, 1], [1529, 9468, 1], [1530, 9468, 1], [1531, 9468, 1], [1532, 9468, 1], [1533, 9468, 1], [1534, 9468, 1], [1535, 9468, 1], [1536, 9468, 1], [1537, 9468, 1], [1538, 9468, 1], [1539, 9468, 1], [1540, 9468, 1], [1541, 9468, 1], [1542, 9468, 1], [1543, 9468, 1], [1544, 9468, 1], [1545, 9468, 1], [1546, 9468, 1], [1547, 9468, 1], [1548, 9468, 1], [1549, 9468, 1], [1550, 9468, 1], [1551, 9468, 1], [1552, 9468, 1], [1553, 9468, 1], [1554, 9468, 1], [1555, 9468, 1], [1556, 9468, 1], [1557, 9468, 1], [1558, 9468, 1], [1559, 9468, 1], [1560, 9468, 1], [1561, 9468, 1], [1562, 9468, 1], [1563, 9468, 1], [1564, 9468, 1], [1565, 9468, 1], [1566, 9468, 1], [1567, 9468, 1], [1568, 9468, 1], [1569, 9468, 1], [1570, 9468, 1], [1571, 9468, 1], [1572, 9468, 1], [1573, 9468, 1], [1574, 9468, 1], [1575, 9468, 1], [1576, 9468, 1], [1577, 9468, 1], [1578, 9468, 1], [1579, 9468, 1], [1580, 9468, 1], [1581, 9468, 1], [1582, 9468, 1], [1583, 9468, 1], [1584, 9468, 1], [1585, 9468, 1], [1586, 9468, 1], [1587, 9468, 1], [1588, 9468, 1], [1589, 9468, 1], [1590, 9468, 1], [1591, 9468, 1], [1592, 9468, 1], [1593, 9468, 1], [1594, 9468, 1], [1595, 9468, 1], [1596, 9468, 1], [1597, 9468, 1], [1598, 9468, 1], [1599, 9468, 1], [1600, 9468, 1], [1601, 9468, 1], [1602, 9468, 1], [1603, 9468, 1], [1604, 9444, 1], [1605, 9444, 1], [1606, 9444, 1], [1607, 9444, 1], [1608, 9444, 1], [1609, 9444, 1], [1610, 9444, 1], [1611, 9444, 1], [1612, 9444, 1], [1613, 9444, 1], [1614, 9444, 1], [1615, 9444, 1], [1616, 9444, 1], [1617, 9444, 1], [1618, 9444, 1], [1619, 9444, 1], [1620, 9444, 1], [1621, 9444, 1], [1622, 9444, 1], [1623, 9444, 1], [1624, 9444, 1], [1625, 9444, 1], [1626, 9444, 1], [1627, 9444, 1], [1628, 9444, 1], [1629, 9444, 1], [1630, 9444, 1], [1631, 9444, 1], [1632, 9444, 1], [1633, 9444, 1], [1634, 9444, 1], [1635, 9444, 1], [1636, 9444, 1], [1637, 9444, 1], [1638, 9444, 1], [1639, 9444, 1], [1640, 9444, 1], [1641, 9444, 1], [1642, 9444, 1], [1643, 9444, 1], [1644, 9444, 1], [1645, 9444, 1], [1646, 9444, 1], [1647, 9444, 1], [1648, 9444, 1], [1649, 9444, 1], [1650, 9444, 1], [1651, 9444, 1], [1652, 9444, 1], [1653, 9444, 1], [1654, 9444, 1], [1655, 9444, 1], [1656, 9444, 1], [1657, 9444, 1], [1658, 9444, 1], [1659, 9444, 1], [1660, 9444, 1], [1661, 9444, 1], [1662, 9444, 1], [1663, 9444, 1], [1664, 9444, 1], [1665, 9444, 1], [1666, 9444, 1], [1667, 9444, 1], [1668, 9444, 1], [1669, 9444, 1], [1670, 9444, 1], [1671, 9444, 1], [1672, 9444, 1], [1673, 9444, 1], [1674, 9444, 1], [1675, 9444, 1], [1676, 9444, 1], [1677, 9444, 1], [1678, 9444, 1], [1679, 9444, 1], [1680, 9444, 1], [1681, 9444, 1], [1682, 9444, 1], [1683, 9444, 1], [1684, 9444, 1], [1685, 9444, 1], [1686, 9444, 1], [1687, 9444, 1], [1688, 9444, 1], [1689, 9444, 1], [1690, 9444, 1], [1691, 9444, 1], [1692, 9444, 1], [1693, 9444, 1], [1694, 9444, 1], [1695, 9444, 1], [1696, 9444, 1], [1697, 9444, 1], [1698, 9444, 1], [1699, 9444, 1], [1700, 9444, 1], [1701, 9444, 1], [1702, 9444, 1], [1703, 9444, 1], [1704, 9444, 1], [1705, 9444, 1], [1706, 9444, 1], [1707, 9444, 1], [1708, 9444, 1], [1709, 9444, 1], [1710, 9444, 1], [1711, 9444, 1], [1712, 9444, 1], [1713, 9444, 1], [1714, 9444, 1], [1715, 9444, 1], [1716, 9444, 1], [1717, 9444, 1], [1718, 9444, 1], [1719, 9444, 1], [1720, 9444, 1], [1721, 9444, 1], [1722, 9444, 1], [1723, 9444, 1], [1724, 9444, 1], [1725, 9444, 1], [1726, 9444, 1], [1727, 9444, 1], [1728, 9444, 1], [1729, 9444, 1], [1730, 9444, 1], [1731, 9444, 1], [1732, 9444, 1], [1733, 9444, 1], [1734, 9444, 1], [1735, 9444, 1], [1736, 9444, 1], [1737, 9444, 1], [1738, 9444, 1], [1739, 9444, 1], [1740, 9444, 1], [1741, 9444, 1], [1742, 9444, 1], [1743, 9444, 1], [1744, 9463, 1], [1745, 9463, 1], [1746, 9463, 1], [1747, 9463, 1], [1748, 9463, 1], [1749, 9463, 1], [1750, 9463, 1], [1751, 9463, 1], [1752, 9463, 1], [1753, 9463, 1], [1754, 9463, 1], [1755, 9463, 1], [1756, 9463, 1], [1757, 9463, 1], [1758, 9463, 1], [1759, 9463, 1], [1760, 9463, 1], [1761, 9463, 1], [1762, 9463, 1], [1763, 9463, 1], [1764, 9463, 1], [1765, 9463, 1], [1766, 9463, 1], [1767, 9463, 1], [1768, 9463, 1], [1769, 9463, 1], [1770, 9463, 1], [1771, 9463, 1], [1772, 9463, 1], [1773, 9463, 1], [1774, 9463, 1], [1775, 9463, 1], [1776, 9463, 1], [1777, 9463, 1], [1778, 9463, 1], [1779, 9463, 1], [1780, 9463, 1], [1781, 9463, 1], [1782, 9463, 1], [1783, 9463, 1], [1784, 9463, 1], [1785, 9463, 1], [1786, 9463, 1], [1787, 9463, 1], [1788, 9463, 1], [1789, 9463, 1], [1790, 9463, 1], [1791, 9463, 1], [1792, 9463, 1], [1793, 9463, 1], [1794, 9463, 1], [1795, 9463, 1], [1796, 9463, 1], [1797, 9463, 1], [1798, 9463, 1], [1799, 9463, 1], [1800, 9463, 1], [1801, 9463, 1], [1802, 9463, 1], [1803, 9463, 1], [1804, 9463, 1], [1805, 9463, 1], [1806, 9463, 1], [1807, 9463, 1], [1808, 9463, 1], [1809, 9463, 1], [1810, 9463, 1], [1811, 9463, 1], [1812, 9463, 1], [1813, 9463, 1], [1814, 9463, 1], [1815, 9463, 1], [1816, 9463, 1], [1817, 9463, 1], [1818, 9463, 1], [1819, 9463, 1], [1820, 9463, 1], [1821, 9463, 1], [1822, 9463, 1], [1823, 9463, 1], [1824, 9463, 1], [1825, 9463, 1], [1826, 9463, 1], [1827, 9463, 1], [1828, 9463, 1], [1829, 9463, 1], [1830, 9463, 1], [1831, 9463, 1], [1832, 9463, 1], [1833, 9463, 1], [1834, 9463, 1], [1835, 9463, 1], [1836, 9463, 1], [1837, 9463, 1], [1838, 9463, 1], [1839, 9463, 1], [1840, 9463, 1], [1841, 9463, 1], [1842, 9463, 1], [1843, 9463, 1], [1844, 9463, 1], [1845, 9463, 1], [1846, 9463, 1], [1847, 9463, 1], [1848, 9463, 1], [1849, 9463, 1], [1850, 9463, 1], [1851, 9463, 1], [1852, 9463, 1], [1853, 9463, 1], [1854, 9463, 1], [1855, 9463, 1], [1856, 9463, 1], [1857, 9463, 1], [1858, 9463, 1], [1859, 9463, 1], [1860, 9463, 1], [1861, 9463, 1], [1862, 9463, 1], [1863, 9463, 1], [1864, 9463, 1], [1865, 9463, 1], [1866, 9463, 1], [1867, 9463, 1], [1868, 9463, 1], [1869, 9463, 1], [1870, 9463, 1], [1871, 9463, 1], [1872, 9463, 1], [1873, 9463, 1], [1874, 9463, 1], [1875, 9463, 1], [1876, 9463, 1], [1877, 9463, 1], [1878, 9463, 1], [1879, 9463, 1], [1880, 9463, 1], [1881, 9463, 1], [1882, 9463, 1], [1883, 9463, 1], [1884, 9456, 1], [1885, 9456, 1], [1886, 9456, 1], [1887, 9456, 1], [1888, 9456, 1], [1889, 9456, 1], [1890, 9456, 1], [1891, 9456, 1], [1892, 9456, 1], [1893, 9456, 1], [1894, 9456, 1], [1895, 9456, 1], [1896, 9456, 1], [1897, 9456, 1], [1898, 9456, 1], [1899, 9456, 1], [1900, 9456, 1], [1901, 9456, 1], [1902, 9456, 1], [1903, 9456, 1], [1904, 9456, 1], [1905, 9456, 1], [1906, 9456, 1], [1907, 9456, 1], [1908, 9456, 1], [1909, 9456, 1], [1910, 9456, 1], [1911, 9456, 1], [1912, 9456, 1], [1913, 9456, 1], [1914, 9456, 1], [1915, 9456, 1], [1916, 9456, 1], [1917, 9456, 1], [1918, 9456, 1], [1919, 9456, 1], [1920, 9456, 1], [1921, 9456, 1], [1922, 9456, 1], [1923, 9456, 1], [1924, 9456, 1], [1925, 9456, 1], [1926, 9456, 1], [1927, 9456, 1], [1928, 9456, 1], [1929, 9456, 1], [1930, 9456, 1], [1931, 9456, 1], [1932, 9456, 1], [1933, 9456, 1], [1934, 9456, 1], [1935, 9456, 1], [1936, 9456, 1], [1937, 9456, 1], [1938, 9456, 1], [1939, 9456, 1], [1940, 9456, 1], [1941, 9456, 1], [1942, 9456, 1], [1943, 9456, 1], [1944, 9456, 1], [1945, 9456, 1], [1946, 9456, 1], [1947, 9456, 1], [1948, 9456, 1], [1949, 9456, 1], [1950, 9456, 1], [1951, 9456, 1], [1952, 9456, 1], [1953, 9456, 1], [1954, 9456, 1], [1955, 9456, 1], [1956, 9456, 1], [1957, 9456, 1], [1958, 9456, 1], [1959, 9456, 1], [1960, 9456, 1], [1961, 9456, 1], [1962, 9456, 1], [1963, 9456, 1], [1964, 9456, 1], [1965, 9456, 1], [1966, 9456, 1], [1967, 9456, 1], [1968, 9456, 1], [1969, 9456, 1], [1970, 9456, 1], [1971, 9456, 1], [1972, 9456, 1], [1973, 9456, 1], [1974, 9456, 1], [1975, 9456, 1], [1976, 9456, 1], [1977, 9456, 1], [1978, 9456, 1], [1979, 9456, 1], [1980, 9456, 1], [1981, 9456, 1], [1982, 9456, 1], [1983, 9456, 1], [1984, 9456, 1], [1985, 9456, 1], [1986, 9456, 1], [1987, 9456, 1], [1988, 9456, 1], [1989, 9456, 1], [1990, 9456, 1], [1991, 9456, 1], [1992, 9456, 1], [1993, 9456, 1], [1994, 9456, 1], [1995, 9456, 1], [1996, 9456, 1], [1997, 9456, 1], [1998, 9456, 1], [1999, 9456, 1], [2000, 9456, 1], [2001, 9456, 1], [2002, 9456, 1], [2003, 9456, 1], [2004, 9456, 1], [2005, 9456, 1], [2006, 9456, 1], [2007, 9456, 1], [2008, 9456, 1], [2009, 9456, 1], [2010, 9456, 1], [2011, 9456, 1], [2012, 9456, 1], [2013, 9456, 1], [2014, 9456, 1], [2015, 9456, 1], [2016, 9456, 1], [2017, 9456, 1], [2018, 9456, 1], [2019, 9456, 1], [2020, 9456, 1], [2021, 9456, 1], [2022, 9456, 1], [2023, 9456, 1], [2024, 9446, 1], [2025, 9446, 1], [2026, 9446, 1], [2027, 9446, 1], [2028, 9446, 1], [2029, 9446, 1], [2030, 9446, 1], [2031, 9446, 1], [2032, 9446, 1], [2033, 9446, 1], [2034, 9446, 1], [2035, 9446, 1], [2036, 9446, 1], [2037, 9446, 1], [2038, 9446, 1], [2039, 9446, 1], [2040, 9446, 1], [2041, 9446, 1], [2042, 9446, 1], [2043, 9446, 1], [2044, 9446, 1], [2045, 9446, 1], [2046, 9446, 1], [2047, 9446, 1], [2048, 9446, 1], [2049, 9446, 1], [2050, 9446, 1], [2051, 9446, 1], [2052, 9446, 1], [2053, 9446, 1], [2054, 9446, 1], [2055, 9446, 1], [2056, 9446, 1], [2057, 9446, 1], [2058, 9446, 1], [2059, 9446, 1], [2060, 9446, 1], [2061, 9446, 1], [2062, 9446, 1], [2063, 9446, 1], [2064, 9446, 1], [2065, 9446, 1], [2066, 9446, 1], [2067, 9446, 1], [2068, 9446, 1], [2069, 9446, 1], [2070, 9446, 1], [2071, 9446, 1], [2072, 9446, 1], [2073, 9446, 1], [2074, 9446, 1], [2075, 9446, 1], [2076, 9446, 1], [2077, 9446, 1], [2078, 9446, 1], [2079, 9446, 1], [2080, 9446, 1], [2081, 9446, 1], [2082, 9446, 1], [2083, 9446, 1], [2084, 9446, 1], [2085, 9446, 1], [2086, 9446, 1], [2087, 9446, 1], [2088, 9446, 1], [2089, 9446, 1], [2090, 9446, 1], [2091, 9446, 1], [2092, 9446, 1], [2093, 9446, 1], [2094, 9446, 1], [2095, 9446, 1], [2096, 9446, 1], [2097, 9446, 1], [2098, 9446, 1], [2099, 9446, 1], [2100, 9446, 1], [2101, 9446, 1], [2102, 9446, 1], [2103, 9446, 1], [2104, 9446, 1], [2105, 9446, 1], [2106, 9446, 1], [2107, 9446, 1], [2108, 9446, 1], [2109, 9446, 1], [2110, 9446, 1], [2111, 9446, 1], [2112, 9446, 1], [2113, 9446, 1], [2114, 9446, 1], [2115, 9446, 1], [2116, 9446, 1], [2117, 9446, 1], [2118, 9446, 1], [2119, 9446, 1], [2120, 9446, 1], [2121, 9446, 1], [2122, 9446, 1], [2123, 9446, 1], [2124, 9446, 1], [2125, 9446, 1], [2126, 9446, 1], [2127, 9446, 1], [2128, 9446, 1], [2129, 9446, 1], [2130, 9446, 1], [2131, 9446, 1], [2132, 9446, 1], [2133, 9446, 1], [2134, 9446, 1], [2135, 9446, 1], [2136, 9446, 1], [2137, 9446, 1], [2138, 9446, 1], [2139, 9446, 1], [2140, 9446, 1], [2141, 9446, 1], [2142, 9446, 1], [2143, 9446, 1], [2144, 9446, 1], [2145, 9446, 1], [2146, 9446, 1], [2147, 9446, 1], [2148, 9446, 1], [2149, 9446, 1], [2150, 9446, 1], [2151, 9446, 1], [2152, 9446, 1], [2153, 9446, 1], [2154, 9446, 1], [2155, 9446, 1], [2156, 9446, 1], [2157, 9446, 1], [2158, 9446, 1], [2159, 9446, 1], [2160, 9446, 1], [2161, 9446, 1], [2162, 9446, 1], [2163, 9446, 1], [2164, 9472, 1], [2165, 9472, 1], [2166, 9472, 1], [2167, 9472, 1], [2168, 9472, 1], [2169, 9472, 1], [2170, 9472, 1], [2171, 9472, 1], [2172, 9472, 1], [2173, 9472, 1], [2174, 9472, 1], [2175, 9472, 1], [2176, 9472, 1], [2177, 9472, 1], [2178, 9472, 1], [2179, 9472, 1], [2180, 9472, 1], [2181, 9472, 1], [2182, 9472, 1], [2183, 9472, 1], [2184, 9472, 1], [2185, 9472, 1], [2186, 9472, 1], [2187, 9472, 1], [2188, 9472, 1], [2189, 9472, 1], [2190, 9472, 1], [2191, 9472, 1], [2192, 9472, 1], [2193, 9472, 1], [2194, 9472, 1], [2195, 9472, 1], [2196, 9472, 1], [2197, 9472, 1], [2198, 9472, 1], [2199, 9472, 1], [2200, 9472, 1], [2201, 9472, 1], [2202, 9472, 1], [2203, 9472, 1], [2204, 9472, 1], [2205, 9472, 1], [2206, 9472, 1], [2207, 9472, 1], [2208, 9472, 1], [2209, 9472, 1], [2210, 9472, 1], [2211, 9472, 1], [2212, 9472, 1], [2213, 9472, 1], [2214, 9472, 1], [2215, 9472, 1], [2216, 9472, 1], [2217, 9472, 1], [2218, 9472, 1], [2219, 9472, 1], [2220, 9472, 1], [2221, 9472, 1], [2222, 9472, 1], [2223, 9472, 1], [2224, 9472, 1], [2225, 9472, 1], [2226, 9472, 1], [2227, 9472, 1], [2228, 9472, 1], [2229, 9472, 1], [2230, 9472, 1], [2231, 9472, 1], [2232, 9472, 1], [2233, 9472, 1], [2234, 9472, 1], [2235, 9472, 1], [2236, 9472, 1], [2237, 9472, 1], [2238, 9472, 1], [2239, 9472, 1], [2240, 9472, 1], [2241, 9472, 1], [2242, 9472, 1], [2243, 9472, 1], [2244, 9472, 1], [2245, 9472, 1], [2246, 9472, 1], [2247, 9472, 1], [2248, 9472, 1], [2249, 9472, 1], [2250, 9472, 1], [2251, 9472, 1], [2252, 9472, 1], [2253, 9472, 1], [2254, 9472, 1], [2255, 9472, 1], [2256, 9472, 1], [2257, 9472, 1], [2258, 9472, 1], [2259, 9472, 1], [2260, 9472, 1], [2261, 9472, 1], [2262, 9472, 1], [2263, 9472, 1], [2264, 9472, 1], [2265, 9472, 1], [2266, 9472, 1], [2267, 9472, 1], [2268, 9472, 1], [2269, 9472, 1], [2270, 9472, 1], [2271, 9472, 1], [2272, 9472, 1], [2273, 9472, 1], [2274, 9472, 1], [2275, 9472, 1], [2276, 9472, 1], [2277, 9472, 1], [2278, 9472, 1], [2279, 9472, 1], [2280, 9472, 1], [2281, 9472, 1], [2282, 9472, 1], [2283, 9472, 1], [2284, 9472, 1], [2285, 9472, 1], [2286, 9472, 1], [2287, 9472, 1], [2288, 9472, 1], [2289, 9472, 1], [2290, 9472, 1], [2291, 9472, 1], [2292, 9472, 1], [2293, 9472, 1], [2294, 9472, 1], [2295, 9472, 1], [2296, 9472, 1], [2297, 9472, 1], [2298, 9472, 1], [2299, 9472, 1], [2300, 9472, 1], [2301, 9472, 1], [2302, 9472, 1], [2303, 9472, 1], [2304, 9472, 1], [2305, 9472, 1], [2306, 9472, 1], [2307, 9472, 1], [2308, 9472, 1], [2309, 9472, 1], [2310, 9472, 1], [2311, 9472, 1], [2312, 9472, 1], [2313, 9472, 1], [2314, 9472, 1], [2315, 9472, 1], [2316, 9472, 1], [2317, 9472, 1], [2318, 9472, 1], [2319, 9472, 1], [2320, 9472, 1], [2321, 9472, 1], [2322, 9472, 1], [2323, 9472, 1], [2324, 9472, 1], [2325, 9472, 1], [2326, 9472, 1], [2327, 9472, 1], [2328, 9472, 1], [2329, 9472, 1], [2330, 9472, 1], [2331, 9472, 1], [2332, 9472, 1], [2333, 9472, 1], [2334, 9472, 1], [2335, 9472, 1], [2336, 9472, 1], [2337, 9472, 1], [2338, 9472, 1], [2339, 9472, 1], [2340, 9472, 1], [2341, 9472, 1], [2342, 9472, 1], [2343, 9472, 1], [2344, 9472, 1], [2345, 9472, 1], [2346, 9472, 1], [2347, 9472, 1], [2348, 9472, 1], [2349, 9472, 1], [2350, 9472, 1], [2351, 9472, 1], [2352, 9472, 1], [2353, 9472, 1], [2354, 9472, 1], [2355, 9472, 1], [2356, 9472, 1], [2357, 9472, 1], [2358, 9472, 1], [2359, 9472, 1], [2360, 9472, 1], [2361, 9472, 1], [2362, 9472, 1], [2363, 9472, 1], [2364, 9472, 1], [2365, 9472, 1], [2366, 9472, 1], [2367, 9472, 1], [2368, 9472, 1], [2369, 9472, 1], [2370, 9472, 1], [2371, 9472, 1], [2372, 9472, 1], [2373, 9472, 1], [2374, 9472, 1], [2375, 9472, 1], [2376, 9472, 1], [2377, 9472, 1], [2378, 9472, 1], [2379, 9472, 1], [2380, 9472, 1], [2381, 9472, 1], [2382, 9472, 1], [2383, 9472, 1], [2384, 9472, 1], [2385, 9472, 1], [2386, 9472, 1], [2387, 9472, 1], [2388, 9472, 1], [2389, 9472, 1], [2390, 9472, 1], [2391, 9472, 1], [2392, 9472, 1], [2393, 9472, 1], [2394, 9472, 1], [2395, 9472, 1], [2396, 9472, 1], [2397, 9472, 1], [2398, 9472, 1], [2399, 9472, 1], [2400, 9472, 1], [2401, 9472, 1], [2402, 9472, 1], [2403, 9472, 1], [2404, 9472, 1], [2405, 9472, 1], [2406, 9472, 1], [2407, 9472, 1], [2408, 9472, 1], [2409, 9472, 1], [2410, 9472, 1], [2411, 9472, 1], [2412, 9472, 1], [2413, 9472, 1], [2414, 9472, 1], [2415, 9472, 1], [2416, 9472, 1], [2417, 9472, 1], [2418, 9472, 1], [2419, 9472, 1], [2420, 9472, 1], [2421, 9472, 1], [2422, 9472, 1], [2423, 9472, 1], [2424, 9472, 1], [2425, 9472, 1], [2426, 9472, 1], [2427, 9472, 1], [2428, 9472, 1], [2429, 9472, 1], [2430, 9472, 1], [2431, 9472, 1], [2432, 9472, 1], [2433, 9472, 1], [2434, 9472, 1], [2435, 9472, 1], [2436, 9472, 1], [2437, 9472, 1], [2438, 9472, 1], [2439, 9472, 1], [2440, 9472, 1], [2441, 9472, 1], [2442, 9472, 1], [2443, 9472, 1], [2444, 9446, 1], [2445, 9446, 1], [2446, 9446, 1], [2447, 9446, 1], [2448, 9446, 1], [2449, 9446, 1], [2450, 9446, 1], [2451, 9446, 1], [2452, 9446, 1], [2453, 9446, 1], [2454, 9446, 1], [2455, 9446, 1], [2456, 9446, 1], [2457, 9446, 1], [2458, 9446, 1], [2459, 9446, 1], [2460, 9446, 1], [2461, 9446, 1], [2462, 9446, 1], [2463, 9446, 1], [2464, 9446, 1], [2465, 9446, 1], [2466, 9446, 1], [2467, 9446, 1], [2468, 9446, 1], [2469, 9446, 1], [2470, 9446, 1], [2471, 9446, 1], [2472, 9446, 1], [2473, 9446, 1], [2474, 9446, 1], [2475, 9446, 1], [2476, 9446, 1], [2477, 9446, 1], [2478, 9446, 1], [2479, 9446, 1], [2480, 9446, 1], [2481, 9446, 1], [2482, 9446, 1], [2483, 9446, 1], [2484, 9446, 1], [2485, 9446, 1], [2486, 9446, 1], [2487, 9446, 1], [2488, 9446, 1], [2489, 9446, 1], [2490, 9446, 1], [2491, 9446, 1], [2492, 9446, 1], [2493, 9446, 1], [2494, 9446, 1], [2495, 9446, 1], [2496, 9446, 1], [2497, 9446, 1], [2498, 9446, 1], [2499, 9446, 1], [2500, 9446, 1], [2501, 9446, 1], [2502, 9446, 1], [2503, 9446, 1], [2504, 9446, 1], [2505, 9446, 1], [2506, 9446, 1], [2507, 9446, 1], [2508, 9446, 1], [2509, 9446, 1], [2510, 9446, 1], [2511, 9446, 1], [2512, 9446, 1], [2513, 9446, 1], [2514, 9446, 1], [2515, 9446, 1], [2516, 9446, 1], [2517, 9446, 1], [2518, 9446, 1], [2519, 9446, 1], [2520, 9446, 1], [2521, 9446, 1], [2522, 9446, 1], [2523, 9446, 1], [2524, 9446, 1], [2525, 9446, 1], [2526, 9446, 1], [2527, 9446, 1], [2528, 9446, 1], [2529, 9446, 1], [2530, 9446, 1], [2531, 9446, 1], [2532, 9446, 1], [2533, 9446, 1], [2534, 9446, 1], [2535, 9446, 1], [2536, 9446, 1], [2537, 9446, 1], [2538, 9446, 1], [2539, 9446, 1], [2540, 9446, 1], [2541, 9446, 1], [2542, 9446, 1], [2543, 9446, 1], [2544, 9446, 1], [2545, 9446, 1], [2546, 9446, 1], [2547, 9446, 1], [2548, 9446, 1], [2549, 9446, 1], [2550, 9446, 1], [2551, 9446, 1], [2552, 9446, 1], [2553, 9446, 1], [2554, 9446, 1], [2555, 9446, 1], [2556, 9446, 1], [2557, 9446, 1], [2558, 9446, 1], [2559, 9446, 1], [2560, 9446, 1], [2561, 9446, 1], [2562, 9446, 1], [2563, 9446, 1], [2564, 9446, 1], [2565, 9446, 1], [2566, 9446, 1], [2567, 9446, 1], [2568, 9446, 1], [2569, 9446, 1], [2570, 9446, 1], [2571, 9446, 1], [2572, 9446, 1], [2573, 9446, 1], [2574, 9446, 1], [2575, 9446, 1], [2576, 9446, 1], [2577, 9446, 1], [2578, 9446, 1], [2579, 9446, 1], [2580, 9446, 1], [2581, 9446, 1], [2582, 9446, 1], [2583, 9446, 1], [2584, 9456, 1], [2585, 9456, 1], [2586, 9456, 1], [2587, 9456, 1], [2588, 9456, 1], [2589, 9456, 1], [2590, 9456, 1], [2591, 9456, 1], [2592, 9456, 1], [2593, 9456, 1], [2594, 9456, 1], [2595, 9456, 1], [2596, 9456, 1], [2597, 9456, 1], [2598, 9456, 1], [2599, 9456, 1], [2600, 9456, 1], [2601, 9456, 1], [2602, 9456, 1], [2603, 9456, 1], [2604, 9456, 1], [2605, 9456, 1], [2606, 9456, 1], [2607, 9456, 1], [2608, 9456, 1], [2609, 9456, 1], [2610, 9456, 1], [2611, 9456, 1], [2612, 9456, 1], [2613, 9456, 1], [2614, 9456, 1], [2615, 9456, 1], [2616, 9456, 1], [2617, 9456, 1], [2618, 9456, 1], [2619, 9456, 1], [2620, 9456, 1], [2621, 9456, 1], [2622, 9456, 1], [2623, 9456, 1], [2624, 9456, 1], [2625, 9456, 1], [2626, 9456, 1], [2627, 9456, 1], [2628, 9456, 1], [2629, 9456, 1], [2630, 9456, 1], [2631, 9456, 1], [2632, 9456, 1], [2633, 9456, 1], [2634, 9456, 1], [2635, 9456, 1], [2636, 9456, 1], [2637, 9456, 1], [2638, 9456, 1], [2639, 9456, 1], [2640, 9456, 1], [2641, 9456, 1], [2642, 9456, 1], [2643, 9456, 1], [2644, 9456, 1], [2645, 9456, 1], [2646, 9456, 1], [2647, 9456, 1], [2648, 9456, 1], [2649, 9456, 1], [2650, 9456, 1], [2651, 9456, 1], [2652, 9456, 1], [2653, 9456, 1], [2654, 9456, 1], [2655, 9456, 1], [2656, 9456, 1], [2657, 9456, 1], [2658, 9456, 1], [2659, 9456, 1], [2660, 9456, 1], [2661, 9456, 1], [2662, 9456, 1], [2663, 9456, 1], [2664, 9456, 1], [2665, 9456, 1], [2666, 9456, 1], [2667, 9456, 1], [2668, 9456, 1], [2669, 9456, 1], [2670, 9456, 1], [2671, 9456, 1], [2672, 9456, 1], [2673, 9456, 1], [2674, 9456, 1], [2675, 9456, 1], [2676, 9456, 1], [2677, 9456, 1], [2678, 9456, 1], [2679, 9456, 1], [2680, 9456, 1], [2681, 9456, 1], [2682, 9456, 1], [2683, 9456, 1], [2684, 9456, 1], [2685, 9456, 1], [2686, 9456, 1], [2687, 9456, 1], [2688, 9456, 1], [2689, 9456, 1], [2690, 9456, 1], [2691, 9456, 1], [2692, 9456, 1], [2693, 9456, 1], [2694, 9456, 1], [2695, 9456, 1], [2696, 9456, 1], [2697, 9456, 1], [2698, 9456, 1], [2699, 9456, 1], [2700, 9456, 1], [2701, 9456, 1], [2702, 9456, 1], [2703, 9456, 1], [2704, 9456, 1], [2705, 9456, 1], [2706, 9456, 1], [2707, 9456, 1], [2708, 9456, 1], [2709, 9456, 1], [2710, 9456, 1], [2711, 9456, 1], [2712, 9456, 1], [2713, 9456, 1], [2714, 9456, 1], [2715, 9456, 1], [2716, 9456, 1], [2717, 9456, 1], [2718, 9456, 1], [2719, 9456, 1], [2720, 9456, 1], [2721, 9456, 1], [2722, 9456, 1], [2723, 9456, 1], [2724, 9461, 1], [2725, 9461, 1], [2726, 9461, 1], [2727, 9461, 1], [2728, 9461, 1], [2729, 9461, 1], [2730, 9461, 1], [2731, 9461, 1], [2732, 9461, 1], [2733, 9461, 1], [2734, 9461, 1], [2735, 9461, 1], [2736, 9461, 1], [2737, 9461, 1], [2738, 9461, 1], [2739, 9461, 1], [2740, 9461, 1], [2741, 9461, 1], [2742, 9461, 1], [2743, 9461, 1], [2744, 9461, 1], [2745, 9461, 1], [2746, 9461, 1], [2747, 9461, 1], [2748, 9461, 1], [2749, 9461, 1], [2750, 9461, 1], [2751, 9461, 1], [2752, 9461, 1], [2753, 9461, 1], [2754, 9461, 1], [2755, 9461, 1], [2756, 9461, 1], [2757, 9461, 1], [2758, 9461, 1], [2759, 9461, 1], [2760, 9461, 1], [2761, 9461, 1], [2762, 9461, 1], [2763, 9461, 1], [2764, 9461, 1], [2765, 9461, 1], [2766, 9461, 1], [2767, 9461, 1], [2768, 9461, 1], [2769, 9461, 1], [2770, 9461, 1], [2771, 9461, 1], [2772, 9461, 1], [2773, 9461, 1], [2774, 9461, 1], [2775, 9461, 1], [2776, 9461, 1], [2777, 9461, 1], [2778, 9461, 1], [2779, 9461, 1], [2780, 9461, 1], [2781, 9461, 1], [2782, 9461, 1], [2783, 9461, 1], [2784, 9461, 1], [2785, 9461, 1], [2786, 9461, 1], [2787, 9461, 1], [2788, 9461, 1], [2789, 9461, 1], [2790, 9461, 1], [2791, 9461, 1], [2792, 9461, 1], [2793, 9461, 1], [2794, 9461, 1], [2795, 9461, 1], [2796, 9461, 1], [2797, 9461, 1], [2798, 9461, 1], [2799, 9461, 1], [2800, 9461, 1], [2801, 9461, 1], [2802, 9461, 1], [2803, 9461, 1], [2804, 9461, 1], [2805, 9461, 1], [2806, 9461, 1], [2807, 9461, 1], [2808, 9461, 1], [2809, 9461, 1], [2810, 9461, 1], [2811, 9461, 1], [2812, 9461, 1], [2813, 9461, 1], [2814, 9461, 1], [2815, 9461, 1], [2816, 9461, 1], [2817, 9461, 1], [2818, 9461, 1], [2819, 9461, 1], [2820, 9461, 1], [2821, 9461, 1], [2822, 9461, 1], [2823, 9461, 1], [2824, 9461, 1], [2825, 9461, 1], [2826, 9461, 1], [2827, 9461, 1], [2828, 9461, 1], [2829, 9461, 1], [2830, 9461, 1], [2831, 9461, 1], [2832, 9461, 1], [2833, 9461, 1], [2834, 9461, 1], [2835, 9461, 1], [2836, 9461, 1], [2837, 9461, 1], [2838, 9461, 1], [2839, 9461, 1], [2840, 9461, 1], [2841, 9461, 1], [2842, 9461, 1], [2843, 9461, 1], [2844, 9461, 1], [2845, 9461, 1], [2846, 9461, 1], [2847, 9461, 1], [2848, 9461, 1], [2849, 9461, 1], [2850, 9461, 1], [2851, 9461, 1], [2852, 9461, 1], [2853, 9461, 1], [2854, 9461, 1], [2855, 9461, 1], [2856, 9461, 1], [2857, 9461, 1], [2858, 9461, 1], [2859, 9461, 1], [2860, 9461, 1], [2861, 9461, 1], [2862, 9461, 1], [2863, 9461, 1], [2864, 9452, 1], [2865, 9452, 1], [2866, 9452, 1], [2867, 9452, 1], [2868, 9452, 1], [2869, 9452, 1], [2870, 9452, 1], [2871, 9452, 1], [2872, 9452, 1], [2873, 9452, 1], [2874, 9452, 1], [2875, 9452, 1], [2876, 9452, 1], [2877, 9452, 1], [2878, 9452, 1], [2879, 9452, 1], [2880, 9452, 1], [2881, 9452, 1], [2882, 9452, 1], [2883, 9452, 1], [2884, 9452, 1], [2885, 9452, 1], [2886, 9452, 1], [2887, 9452, 1], [2888, 9452, 1], [2889, 9452, 1], [2890, 9452, 1], [2891, 9452, 1], [2892, 9452, 1], [2893, 9452, 1], [2894, 9452, 1], [2895, 9452, 1], [2896, 9452, 1], [2897, 9452, 1], [2898, 9452, 1], [2899, 9452, 1], [2900, 9452, 1], [2901, 9452, 1], [2902, 9452, 1], [2903, 9452, 1], [2904, 9452, 1], [2905, 9452, 1], [2906, 9452, 1], [2907, 9452, 1], [2908, 9452, 1], [2909, 9452, 1], [2910, 9452, 1], [2911, 9452, 1], [2912, 9452, 1], [2913, 9452, 1], [2914, 9452, 1], [2915, 9452, 1], [2916, 9452, 1], [2917, 9452, 1], [2918, 9452, 1], [2919, 9452, 1], [2920, 9452, 1], [2921, 9452, 1], [2922, 9452, 1], [2923, 9452, 1], [2924, 9452, 1], [2925, 9452, 1], [2926, 9452, 1], [2927, 9452, 1], [2928, 9452, 1], [2929, 9452, 1], [2930, 9452, 1], [2931, 9452, 1], [2932, 9452, 1], [2933, 9452, 1], [2934, 9452, 1], [2935, 9452, 1], [2936, 9452, 1], [2937, 9452, 1], [2938, 9452, 1], [2939, 9452, 1], [2940, 9452, 1], [2941, 9452, 1], [2942, 9452, 1], [2943, 9452, 1], [2944, 9452, 1], [2945, 9452, 1], [2946, 9452, 1], [2947, 9452, 1], [2948, 9452, 1], [2949, 9452, 1], [2950, 9452, 1], [2951, 9452, 1], [2952, 9452, 1], [2953, 9452, 1], [2954, 9452, 1], [2955, 9452, 1], [2956, 9452, 1], [2957, 9452, 1], [2958, 9452, 1], [2959, 9452, 1], [2960, 9452, 1], [2961, 9452, 1], [2962, 9452, 1], [2963, 9452, 1], [2964, 9452, 1], [2965, 9452, 1], [2966, 9452, 1], [2967, 9452, 1], [2968, 9452, 1], [2969, 9452, 1], [2970, 9452, 1], [2971, 9452, 1], [2972, 9452, 1], [2973, 9452, 1], [2974, 9452, 1], [2975, 9452, 1], [2976, 9452, 1], [2977, 9452, 1], [2978, 9452, 1], [2979, 9452, 1], [2980, 9452, 1], [2981, 9452, 1], [2982, 9452, 1], [2983, 9452, 1], [2984, 9452, 1], [2985, 9452, 1], [2986, 9452, 1], [2987, 9452, 1], [2988, 9452, 1], [2989, 9452, 1], [2990, 9452, 1], [2991, 9452, 1], [2992, 9452, 1], [2993, 9452, 1], [2994, 9452, 1], [2995, 9452, 1], [2996, 9452, 1], [2997, 9452, 1], [2998, 9452, 1], [2999, 9452, 1], [3000, 9452, 1], [3001, 9452, 1], [3002, 9452, 1], [3003, 9452, 1], [3004, 9469, 1], [3005, 9469, 1], [3006, 9469, 1], [3007, 9469, 1], [3008, 9469, 1], [3009, 9469, 1], [3010, 9469, 1], [3011, 9469, 1], [3012, 9469, 1], [3013, 9469, 1], [3014, 9469, 1], [3015, 9469, 1], [3016, 9469, 1], [3017, 9469, 1], [3018, 9469, 1], [3019, 9469, 1], [3020, 9469, 1], [3021, 9469, 1], [3022, 9469, 1], [3023, 9469, 1], [3024, 9469, 1], [3025, 9469, 1], [3026, 9469, 1], [3027, 9469, 1], [3028, 9469, 1], [3029, 9469, 1], [3030, 9469, 1], [3031, 9469, 1], [3032, 9469, 1], [3033, 9469, 1], [3034, 9469, 1], [3035, 9469, 1], [3036, 9469, 1], [3037, 9469, 1], [3038, 9469, 1], [3039, 9469, 1], [3040, 9469, 1], [3041, 9469, 1], [3042, 9469, 1], [3043, 9469, 1], [3044, 9469, 1], [3045, 9469, 1], [3046, 9469, 1], [3047, 9469, 1], [3048, 9469, 1], [3049, 9469, 1], [3050, 9469, 1], [3051, 9469, 1], [3052, 9469, 1], [3053, 9469, 1], [3054, 9469, 1], [3055, 9469, 1], [3056, 9469, 1], [3057, 9469, 1], [3058, 9469, 1], [3059, 9469, 1], [3060, 9469, 1], [3061, 9469, 1], [3062, 9469, 1], [3063, 9469, 1], [3064, 9469, 1], [3065, 9469, 1], [3066, 9469, 1], [3067, 9469, 1], [3068, 9469, 1], [3069, 9469, 1], [3070, 9469, 1], [3071, 9469, 1], [3072, 9469, 1], [3073, 9469, 1], [3074, 9469, 1], [3075, 9469, 1], [3076, 9469, 1], [3077, 9469, 1], [3078, 9469, 1], [3079, 9469, 1], [3080, 9469, 1], [3081, 9469, 1], [3082, 9469, 1], [3083, 9469, 1], [3084, 9469, 1], [3085, 9469, 1], [3086, 9469, 1], [3087, 9469, 1], [3088, 9469, 1], [3089, 9469, 1], [3090, 9469, 1], [3091, 9469, 1], [3092, 9469, 1], [3093, 9469, 1], [3094, 9469, 1], [3095, 9469, 1], [3096, 9469, 1], [3097, 9469, 1], [3098, 9469, 1], [3099, 9469, 1], [3100, 9469, 1], [3101, 9469, 1], [3102, 9469, 1], [3103, 9469, 1], [3104, 9469, 1], [3105, 9469, 1], [3106, 9469, 1], [3107, 9469, 1], [3108, 9469, 1], [3109, 9469, 1], [3110, 9469, 1], [3111, 9469, 1], [3112, 9469, 1], [3113, 9469, 1], [3114, 9469, 1], [3115, 9469, 1], [3116, 9469, 1], [3117, 9469, 1], [3118, 9469, 1], [3119, 9469, 1], [3120, 9469, 1], [3121, 9469, 1], [3122, 9469, 1], [3123, 9469, 1], [3124, 9469, 1], [3125, 9469, 1], [3126, 9469, 1], [3127, 9469, 1], [3128, 9469, 1], [3129, 9469, 1], [3130, 9469, 1], [3131, 9469, 1], [3132, 9469, 1], [3133, 9469, 1], [3134, 9469, 1], [3135, 9469, 1], [3136, 9469, 1], [3137, 9469, 1], [3138, 9469, 1], [3139, 9469, 1], [3140, 9469, 1], [3141, 9469, 1], [3142, 9469, 1], [3143, 9469, 1], [3144, 9469, 1], [3145, 9469, 1], [3146, 9469, 1], [3147, 9469, 1], [3148, 9469, 1], [3149, 9469, 1], [3150, 9469, 1], [3151, 9469, 1], [3152, 9469, 1], [3153, 9469, 1], [3154, 9469, 1], [3155, 9469, 1], [3156, 9469, 1], [3157, 9469, 1], [3158, 9469, 1], [3159, 9469, 1], [3160, 9469, 1], [3161, 9469, 1], [3162, 9469, 1], [3163, 9469, 1], [3164, 9469, 1], [3165, 9469, 1], [3166, 9469, 1], [3167, 9469, 1], [3168, 9469, 1], [3169, 9469, 1], [3170, 9469, 1], [3171, 9469, 1], [3172, 9469, 1], [3173, 9469, 1], [3174, 9469, 1], [3175, 9469, 1], [3176, 9469, 1], [3177, 9469, 1], [3178, 9469, 1], [3179, 9469, 1], [3180, 9469, 1], [3181, 9469, 1], [3182, 9469, 1], [3183, 9469, 1], [3184, 9469, 1], [3185, 9469, 1], [3186, 9469, 1], [3187, 9469, 1], [3188, 9469, 1], [3189, 9469, 1], [3190, 9469, 1], [3191, 9469, 1], [3192, 9469, 1], [3193, 9469, 1], [3194, 9469, 1], [3195, 9469, 1], [3196, 9469, 1], [3197, 9469, 1], [3198, 9469, 1], [3199, 9469, 1], [3200, 9469, 1], [3201, 9469, 1], [3202, 9469, 1], [3203, 9469, 1], [3204, 9469, 1], [3205, 9469, 1], [3206, 9469, 1], [3207, 9469, 1], [3208, 9469, 1], [3209, 9469, 1], [3210, 9469, 1], [3211, 9469, 1], [3212, 9469, 1], [3213, 9469, 1], [3214, 9469, 1], [3215, 9469, 1], [3216, 9469, 1], [3217, 9469, 1], [3218, 9469, 1], [3219, 9469, 1], [3220, 9469, 1], [3221, 9469, 1], [3222, 9469, 1], [3223, 9469, 1], [3224, 9469, 1], [3225, 9469, 1], [3226, 9469, 1], [3227, 9469, 1], [3228, 9469, 1], [3229, 9469, 1], [3230, 9469, 1], [3231, 9469, 1], [3232, 9469, 1], [3233, 9469, 1], [3234, 9469, 1], [3235, 9469, 1], [3236, 9469, 1], [3237, 9469, 1], [3238, 9469, 1], [3239, 9469, 1], [3240, 9469, 1], [3241, 9469, 1], [3242, 9469, 1], [3243, 9469, 1], [3244, 9469, 1], [3245, 9469, 1], [3246, 9469, 1], [3247, 9469, 1], [3248, 9469, 1], [3249, 9469, 1], [3250, 9469, 1], [3251, 9469, 1], [3252, 9469, 1], [3253, 9469, 1], [3254, 9469, 1], [3255, 9469, 1], [3256, 9469, 1], [3257, 9469, 1], [3258, 9469, 1], [3259, 9469, 1], [3260, 9469, 1], [3261, 9469, 1], [3262, 9469, 1], [3263, 9469, 1], [3264, 9469, 1], [3265, 9469, 1], [3266, 9469, 1], [3267, 9469, 1], [3268, 9469, 1], [3269, 9469, 1], [3270, 9469, 1], [3271, 9469, 1], [3272, 9469, 1], [3273, 9469, 1], [3274, 9469, 1], [3275, 9469, 1], [3276, 9469, 1], [3277, 9469, 1], [3278, 9469, 1], [3279, 9469, 1], [3280, 9469, 1], [3281, 9469, 1], [3282, 9469, 1], [3283, 9469, 1], [3284, 9452, 1], [3285, 9452, 1], [3286, 9452, 1], [3287, 9452, 1], [3288, 9452, 1], [3289, 9452, 1], [3290, 9452, 1], [3291, 9452, 1], [3292, 9452, 1], [3293, 9452, 1], [3294, 9452, 1], [3295, 9452, 1], [3296, 9452, 1], [3297, 9452, 1], [3298, 9452, 1], [3299, 9452, 1], [3300, 9452, 1], [3301, 9452, 1], [3302, 9452, 1], [3303, 9452, 1], [3304, 9452, 1], [3305, 9452, 1], [3306, 9452, 1], [3307, 9452, 1], [3308, 9452, 1], [3309, 9452, 1], [3310, 9452, 1], [3311, 9452, 1], [3312, 9452, 1], [3313, 9452, 1], [3314, 9452, 1], [3315, 9452, 1], [3316, 9452, 1], [3317, 9452, 1], [3318, 9452, 1], [3319, 9452, 1], [3320, 9452, 1], [3321, 9452, 1], [3322, 9452, 1], [3323, 9452, 1], [3324, 9452, 1], [3325, 9452, 1], [3326, 9452, 1], [3327, 9452, 1], [3328, 9452, 1], [3329, 9452, 1], [3330, 9452, 1], [3331, 9452, 1], [3332, 9452, 1], [3333, 9452, 1], [3334, 9452, 1], [3335, 9452, 1], [3336, 9452, 1], [3337, 9452, 1], [3338, 9452, 1], [3339, 9452, 1], [3340, 9452, 1], [3341, 9452, 1], [3342, 9452, 1], [3343, 9452, 1], [3344, 9452, 1], [3345, 9452, 1], [3346, 9452, 1], [3347, 9452, 1], [3348, 9452, 1], [3349, 9452, 1], [3350, 9452, 1], [3351, 9452, 1], [3352, 9452, 1], [3353, 9452, 1], [3354, 9452, 1], [3355, 9452, 1], [3356, 9452, 1], [3357, 9452, 1], [3358, 9452, 1], [3359, 9452, 1], [3360, 9452, 1], [3361, 9452, 1], [3362, 9452, 1], [3363, 9452, 1], [3364, 9452, 1], [3365, 9452, 1], [3366, 9452, 1], [3367, 9452, 1], [3368, 9452, 1], [3369, 9452, 1], [3370, 9452, 1], [3371, 9452, 1], [3372, 9452, 1], [3373, 9452, 1], [3374, 9452, 1], [3375, 9452, 1], [3376, 9452, 1], [3377, 9452, 1], [3378, 9452, 1], [3379, 9452, 1], [3380, 9452, 1], [3381, 9452, 1], [3382, 9452, 1], [3383, 9452, 1], [3384, 9452, 1], [3385, 9452, 1], [3386, 9452, 1], [3387, 9452, 1], [3388, 9452, 1], [3389, 9452, 1], [3390, 9452, 1], [3391, 9452, 1], [3392, 9452, 1], [3393, 9452, 1], [3394, 9452, 1], [3395, 9452, 1], [3396, 9452, 1], [3397, 9452, 1], [3398, 9452, 1], [3399, 9452, 1], [3400, 9452, 1], [3401, 9452, 1], [3402, 9452, 1], [3403, 9452, 1], [3404, 9452, 1], [3405, 9452, 1], [3406, 9452, 1], [3407, 9452, 1], [3408, 9452, 1], [3409, 9452, 1], [3410, 9452, 1], [3411, 9452, 1], [3412, 9452, 1], [3413, 9452, 1], [3414, 9452, 1], [3415, 9452, 1], [3416, 9452, 1], [3417, 9452, 1], [3418, 9452, 1], [3419, 9452, 1], [3420, 9452, 1], [3421, 9452, 1], [3422, 9452, 1], [3423, 9452, 1], [3424, 9461, 1], [3425, 9461, 1], [3426, 9461, 1], [3427, 9461, 1], [3428, 9461, 1], [3429, 9461, 1], [3430, 9461, 1], [3431, 9461, 1], [3432, 9461, 1], [3433, 9461, 1], [3434, 9461, 1], [3435, 9461, 1], [3436, 9461, 1], [3437, 9461, 1], [3438, 9461, 1], [3439, 9461, 1], [3440, 9461, 1], [3441, 9461, 1], [3442, 9461, 1], [3443, 9461, 1], [3444, 9461, 1], [3445, 9461, 1], [3446, 9461, 1], [3447, 9461, 1], [3448, 9461, 1], [3449, 9461, 1], [3450, 9461, 1], [3451, 9461, 1], [3452, 9461, 1], [3453, 9461, 1], [3454, 9461, 1], [3455, 9461, 1], [3456, 9461, 1], [3457, 9461, 1], [3458, 9461, 1], [3459, 9461, 1], [3460, 9461, 1], [3461, 9461, 1], [3462, 9461, 1], [3463, 9461, 1], [3464, 9461, 1], [3465, 9461, 1], [3466, 9461, 1], [3467, 9461, 1], [3468, 9461, 1], [3469, 9461, 1], [3470, 9461, 1], [3471, 9461, 1], [3472, 9461, 1], [3473, 9461, 1], [3474, 9461, 1], [3475, 9461, 1], [3476, 9461, 1], [3477, 9461, 1], [3478, 9461, 1], [3479, 9461, 1], [3480, 9461, 1], [3481, 9461, 1], [3482, 9461, 1], [3483, 9461, 1], [3484, 9461, 1], [3485, 9461, 1], [3486, 9461, 1], [3487, 9461, 1], [3488, 9461, 1], [3489, 9461, 1], [3490, 9461, 1], [3491, 9461, 1], [3492, 9461, 1], [3493, 9461, 1], [3494, 9461, 1], [3495, 9461, 1], [3496, 9461, 1], [3497, 9461, 1], [3498, 9461, 1], [3499, 9461, 1], [3500, 9461, 1], [3501, 9461, 1], [3502, 9461, 1], [3503, 9461, 1], [3504, 9461, 1], [3505, 9461, 1], [3506, 9461, 1], [3507, 9461, 1], [3508, 9461, 1], [3509, 9461, 1], [3510, 9461, 1], [3511, 9461, 1], [3512, 9461, 1], [3513, 9461, 1], [3514, 9461, 1], [3515, 9461, 1], [3516, 9461, 1], [3517, 9461, 1], [3518, 9461, 1], [3519, 9461, 1], [3520, 9461, 1], [3521, 9461, 1], [3522, 9461, 1], [3523, 9461, 1], [3524, 9461, 1], [3525, 9461, 1], [3526, 9461, 1], [3527, 9461, 1], [3528, 9461, 1], [3529, 9461, 1], [3530, 9461, 1], [3531, 9461, 1], [3532, 9461, 1], [3533, 9461, 1], [3534, 9461, 1], [3535, 9461, 1], [3536, 9461, 1], [3537, 9461, 1], [3538, 9461, 1], [3539, 9461, 1], [3540, 9461, 1], [3541, 9461, 1], [3542, 9461, 1], [3543, 9461, 1], [3544, 9461, 1], [3545, 9461, 1], [3546, 9461, 1], [3547, 9461, 1], [3548, 9461, 1], [3549, 9461, 1], [3550, 9461, 1], [3551, 9461, 1], [3552, 9461, 1], [3553, 9461, 1], [3554, 9461, 1], [3555, 9461, 1], [3556, 9461, 1], [3557, 9461, 1], [3558, 9461, 1], [3559, 9461, 1], [3560, 9461, 1], [3561, 9461, 1], [3562, 9461, 1], [3563, 9461, 1], [3564, 9455, 1], [3565, 9455, 1], [3566, 9455, 1], [3567, 9455, 1], [3568, 9455, 1], [3569, 9455, 1], [3570, 9455, 1], [3571, 9455, 1], [3572, 9455, 1], [3573, 9455, 1], [3574, 9455, 1], [3575, 9455, 1], [3576, 9455, 1], [3577, 9455, 1], [3578, 9455, 1], [3579, 9455, 1], [3580, 9455, 1], [3581, 9455, 1], [3582, 9455, 1], [3583, 9455, 1], [3584, 9455, 1], [3585, 9455, 1], [3586, 9455, 1], [3587, 9455, 1], [3588, 9455, 1], [3589, 9455, 1], [3590, 9455, 1], [3591, 9455, 1], [3592, 9455, 1], [3593, 9455, 1], [3594, 9455, 1], [3595, 9455, 1], [3596, 9455, 1], [3597, 9455, 1], [3598, 9455, 1], [3599, 9455, 1], [3600, 9455, 1], [3601, 9455, 1], [3602, 9455, 1], [3603, 9455, 1], [3604, 9455, 1], [3605, 9455, 1], [3606, 9455, 1], [3607, 9455, 1], [3608, 9455, 1], [3609, 9455, 1], [3610, 9455, 1], [3611, 9455, 1], [3612, 9455, 1], [3613, 9455, 1], [3614, 9455, 1], [3615, 9455, 1], [3616, 9455, 1], [3617, 9455, 1], [3618, 9455, 1], [3619, 9455, 1], [3620, 9455, 1], [3621, 9455, 1], [3622, 9455, 1], [3623, 9455, 1], [3624, 9455, 1], [3625, 9455, 1], [3626, 9455, 1], [3627, 9455, 1], [3628, 9455, 1], [3629, 9455, 1], [3630, 9455, 1], [3631, 9455, 1], [3632, 9455, 1], [3633, 9455, 1], [3634, 9455, 1], [3635, 9455, 1], [3636, 9455, 1], [3637, 9455, 1], [3638, 9455, 1], [3639, 9455, 1], [3640, 9455, 1], [3641, 9455, 1], [3642, 9455, 1], [3643, 9455, 1], [3644, 9455, 1], [3645, 9455, 1], [3646, 9455, 1], [3647, 9455, 1], [3648, 9455, 1], [3649, 9455, 1], [3650, 9455, 1], [3651, 9455, 1], [3652, 9455, 1], [3653, 9455, 1], [3654, 9455, 1], [3655, 9455, 1], [3656, 9455, 1], [3657, 9455, 1], [3658, 9455, 1], [3659, 9455, 1], [3660, 9455, 1], [3661, 9455, 1], [3662, 9455, 1], [3663, 9455, 1], [3664, 9455, 1], [3665, 9455, 1], [3666, 9455, 1], [3667, 9455, 1], [3668, 9455, 1], [3669, 9455, 1], [3670, 9455, 1], [3671, 9455, 1], [3672, 9455, 1], [3673, 9455, 1], [3674, 9455, 1], [3675, 9455, 1], [3676, 9455, 1], [3677, 9455, 1], [3678, 9455, 1], [3679, 9455, 1], [3680, 9455, 1], [3681, 9455, 1], [3682, 9455, 1], [3683, 9455, 1], [3684, 9455, 1], [3685, 9455, 1], [3686, 9455, 1], [3687, 9455, 1], [3688, 9455, 1], [3689, 9455, 1], [3690, 9455, 1], [3691, 9455, 1], [3692, 9455, 1], [3693, 9455, 1], [3694, 9455, 1], [3695, 9455, 1], [3696, 9455, 1], [3697, 9455, 1], [3698, 9455, 1], [3699, 9455, 1], [3700, 9455, 1], [3701, 9455, 1], [3702, 9455, 1], [3703, 9455, 1], [3704, 9447, 1], [3705, 9447, 1], [3706, 9447, 1], [3707, 9447, 1], [3708, 9447, 1], [3709, 9447, 1], [3710, 9447, 1], [3711, 9447, 1], [3712, 9447, 1], [3713, 9447, 1], [3714, 9447, 1], [3715, 9447, 1], [3716, 9447, 1], [3717, 9447, 1], [3718, 9447, 1], [3719, 9447, 1], [3720, 9447, 1], [3721, 9447, 1], [3722, 9447, 1], [3723, 9447, 1], [3724, 9447, 1], [3725, 9447, 1], [3726, 9447, 1], [3727, 9447, 1], [3728, 9447, 1], [3729, 9447, 1], [3730, 9447, 1], [3731, 9447, 1], [3732, 9447, 1], [3733, 9447, 1], [3734, 9447, 1], [3735, 9447, 1], [3736, 9447, 1], [3737, 9447, 1], [3738, 9447, 1], [3739, 9447, 1], [3740, 9447, 1], [3741, 9447, 1], [3742, 9447, 1], [3743, 9447, 1], [3744, 9447, 1], [3745, 9447, 1], [3746, 9447, 1], [3747, 9447, 1], [3748, 9447, 1], [3749, 9447, 1], [3750, 9447, 1], [3751, 9447, 1], [3752, 9447, 1], [3753, 9447, 1], [3754, 9447, 1], [3755, 9447, 1], [3756, 9447, 1], [3757, 9447, 1], [3758, 9447, 1], [3759, 9447, 1], [3760, 9447, 1], [3761, 9447, 1], [3762, 9447, 1], [3763, 9447, 1], [3764, 9447, 1], [3765, 9447, 1], [3766, 9447, 1], [3767, 9447, 1], [3768, 9447, 1], [3769, 9447, 1], [3770, 9447, 1], [3771, 9447, 1], [3772, 9447, 1], [3773, 9447, 1], [3774, 9447, 1], [3775, 9447, 1], [3776, 9447, 1], [3777, 9447, 1], [3778, 9447, 1], [3779, 9447, 1], [3780, 9447, 1], [3781, 9447, 1], [3782, 9447, 1], [3783, 9447, 1], [3784, 9447, 1], [3785, 9447, 1], [3786, 9447, 1], [3787, 9447, 1], [3788, 9447, 1], [3789, 9447, 1], [3790, 9447, 1], [3791, 9447, 1], [3792, 9447, 1], [3793, 9447, 1], [3794, 9447, 1], [3795, 9447, 1], [3796, 9447, 1], [3797, 9447, 1], [3798, 9447, 1], [3799, 9447, 1], [3800, 9447, 1], [3801, 9447, 1], [3802, 9447, 1], [3803, 9447, 1], [3804, 9447, 1], [3805, 9447, 1], [3806, 9447, 1], [3807, 9447, 1], [3808, 9447, 1], [3809, 9447, 1], [3810, 9447, 1], [3811, 9447, 1], [3812, 9447, 1], [3813, 9447, 1], [3814, 9447, 1], [3815, 9447, 1], [3816, 9447, 1], [3817, 9447, 1], [3818, 9447, 1], [3819, 9447, 1], [3820, 9447, 1], [3821, 9447, 1], [3822, 9447, 1], [3823, 9447, 1], [3824, 9447, 1], [3825, 9447, 1], [3826, 9447, 1], [3827, 9447, 1], [3828, 9447, 1], [3829, 9447, 1], [3830, 9447, 1], [3831, 9447, 1], [3832, 9447, 1], [3833, 9447, 1], [3834, 9447, 1], [3835, 9447, 1], [3836, 9447, 1], [3837, 9447, 1], [3838, 9447, 1], [3839, 9447, 1], [3840, 9447, 1], [3841, 9447, 1], [3842, 9447, 1], [3843, 9447, 1], [3844, 9465, 1], [3845, 9465, 1], [3846, 9465, 1], [3847, 9465, 1], [3848, 9465, 1], [3849, 9465, 1], [3850, 9465, 1], [3851, 9465, 1], [3852, 9465, 1], [3853, 9465, 1], [3854, 9465, 1], [3855, 9465, 1], [3856, 9465, 1], [3857, 9465, 1], [3858, 9465, 1], [3859, 9465, 1], [3860, 9465, 1], [3861, 9465, 1], [3862, 9465, 1], [3863, 9465, 1], [3864, 9465, 1], [3865, 9465, 1], [3866, 9465, 1], [3867, 9465, 1], [3868, 9465, 1], [3869, 9465, 1], [3870, 9465, 1], [3871, 9465, 1], [3872, 9465, 1], [3873, 9465, 1], [3874, 9465, 1], [3875, 9465, 1], [3876, 9465, 1], [3877, 9465, 1], [3878, 9465, 1], [3879, 9465, 1], [3880, 9465, 1], [3881, 9465, 1], [3882, 9465, 1], [3883, 9465, 1], [3884, 9465, 1], [3885, 9465, 1], [3886, 9465, 1], [3887, 9465, 1], [3888, 9465, 1], [3889, 9465, 1], [3890, 9465, 1], [3891, 9465, 1], [3892, 9465, 1], [3893, 9465, 1], [3894, 9465, 1], [3895, 9465, 1], [3896, 9465, 1], [3897, 9465, 1], [3898, 9465, 1], [3899, 9465, 1], [3900, 9465, 1], [3901, 9465, 1], [3902, 9465, 1], [3903, 9465, 1], [3904, 9465, 1], [3905, 9465, 1], [3906, 9465, 1], [3907, 9465, 1], [3908, 9465, 1], [3909, 9465, 1], [3910, 9465, 1], [3911, 9465, 1], [3912, 9465, 1], [3913, 9465, 1], [3914, 9465, 1], [3915, 9465, 1], [3916, 9465, 1], [3917, 9465, 1], [3918, 9465, 1], [3919, 9465, 1], [3920, 9465, 1], [3921, 9465, 1], [3922, 9465, 1], [3923, 9465, 1], [3924, 9465, 1], [3925, 9465, 1], [3926, 9465, 1], [3927, 9465, 1], [3928, 9465, 1], [3929, 9465, 1], [3930, 9465, 1], [3931, 9465, 1], [3932, 9465, 1], [3933, 9465, 1], [3934, 9465, 1], [3935, 9465, 1], [3936, 9465, 1], [3937, 9465, 1], [3938, 9465, 1], [3939, 9465, 1], [3940, 9465, 1], [3941, 9465, 1], [3942, 9465, 1], [3943, 9465, 1], [3944, 9465, 1], [3945, 9465, 1], [3946, 9465, 1], [3947, 9465, 1], [3948, 9465, 1], [3949, 9465, 1], [3950, 9465, 1], [3951, 9465, 1], [3952, 9465, 1], [3953, 9465, 1], [3954, 9465, 1], [3955, 9465, 1], [3956, 9465, 1], [3957, 9465, 1], [3958, 9465, 1], [3959, 9465, 1], [3960, 9465, 1], [3961, 9465, 1], [3962, 9465, 1], [3963, 9465, 1], [3964, 9465, 1], [3965, 9465, 1], [3966, 9465, 1], [3967, 9465, 1], [3968, 9465, 1], [3969, 9465, 1], [3970, 9465, 1], [3971, 9465, 1], [3972, 9465, 1], [3973, 9465, 1], [3974, 9465, 1], [3975, 9465, 1], [3976, 9465, 1], [3977, 9465, 1], [3978, 9465, 1], [3979, 9465, 1], [3980, 9465, 1], [3981, 9465, 1], [3982, 9465, 1], [3983, 9465, 1], [3984, 9465, 1], [3985, 9465, 1], [3986, 9465, 1], [3987, 9465, 1], [3988, 9465, 1], [3989, 9465, 1], [3990, 9465, 1], [3991, 9465, 1], [3992, 9465, 1], [3993, 9465, 1], [3994, 9465, 1], [3995, 9465, 1], [3996, 9465, 1], [3997, 9465, 1], [3998, 9465, 1], [3999, 9465, 1], [4000, 9465, 1], [4001, 9465, 1], [4002, 9465, 1], [4003, 9465, 1], [4004, 9465, 1], [4005, 9465, 1], [4006, 9465, 1], [4007, 9465, 1], [4008, 9465, 1], [4009, 9465, 1], [4010, 9465, 1], [4011, 9465, 1], [4012, 9465, 1], [4013, 9465, 1], [4014, 9465, 1], [4015, 9465, 1], [4016, 9465, 1], [4017, 9465, 1], [4018, 9465, 1], [4019, 9465, 1], [4020, 9465, 1], [4021, 9465, 1], [4022, 9465, 1], [4023, 9465, 1], [4024, 9465, 1], [4025, 9465, 1], [4026, 9465, 1], [4027, 9465, 1], [4028, 9465, 1], [4029, 9465, 1], [4030, 9465, 1], [4031, 9465, 1], [4032, 9465, 1], [4033, 9465, 1], [4034, 9465, 1], [4035, 9465, 1], [4036, 9465, 1], [4037, 9465, 1], [4038, 9465, 1], [4039, 9465, 1], [4040, 9465, 1], [4041, 9465, 1], [4042, 9465, 1], [4043, 9465, 1], [4044, 9465, 1], [4045, 9465, 1], [4046, 9465, 1], [4047, 9465, 1], [4048, 9465, 1], [4049, 9465, 1], [4050, 9465, 1], [4051, 9465, 1], [4052, 9465, 1], [4053, 9465, 1], [4054, 9465, 1], [4055, 9465, 1], [4056, 9465, 1], [4057, 9465, 1], [4058, 9465, 1], [4059, 9465, 1], [4060, 9465, 1], [4061, 9465, 1], [4062, 9465, 1], [4063, 9465, 1], [4064, 9465, 1], [4065, 9465, 1], [4066, 9465, 1], [4067, 9465, 1], [4068, 9465, 1], [4069, 9465, 1], [4070, 9465, 1], [4071, 9465, 1], [4072, 9465, 1], [4073, 9465, 1], [4074, 9465, 1], [4075, 9465, 1], [4076, 9465, 1], [4077, 9465, 1], [4078, 9465, 1], [4079, 9465, 1], [4080, 9465, 1], [4081, 9465, 1], [4082, 9465, 1], [4083, 9465, 1], [4084, 9465, 1], [4085, 9465, 1], [4086, 9465, 1], [4087, 9465, 1], [4088, 9465, 1], [4089, 9465, 1], [4090, 9465, 1], [4091, 9465, 1], [4092, 9465, 1], [4093, 9465, 1], [4094, 9465, 1], [4095, 9465, 1], [4096, 9465, 1], [4097, 9465, 1], [4098, 9465, 1], [4099, 9465, 1], [4100, 9465, 1], [4101, 9465, 1], [4102, 9465, 1], [4103, 9465, 1], [4104, 9465, 1], [4105, 9465, 1], [4106, 9465, 1], [4107, 9465, 1], [4108, 9465, 1], [4109, 9465, 1], [4110, 9465, 1], [4111, 9465, 1], [4112, 9465, 1], [4113, 9465, 1], [4114, 9465, 1], [4115, 9465, 1], [4116, 9465, 1], [4117, 9465, 1], [4118, 9465, 1], [4119, 9465, 1], [4120, 9465, 1], [4121, 9465, 1], [4122, 9465, 1], [4123, 9465, 1], [4124, 9447, 1], [4125, 9447, 1], [4126, 9447, 1], [4127, 9447, 1], [4128, 9447, 1], [4129, 9447, 1], [4130, 9447, 1], [4131, 9447, 1], [4132, 9447, 1], [4133, 9447, 1], [4134, 9447, 1], [4135, 9447, 1], [4136, 9447, 1], [4137, 9447, 1], [4138, 9447, 1], [4139, 9447, 1], [4140, 9447, 1], [4141, 9447, 1], [4142, 9447, 1], [4143, 9447, 1], [4144, 9447, 1], [4145, 9447, 1], [4146, 9447, 1], [4147, 9447, 1], [4148, 9447, 1], [4149, 9447, 1], [4150, 9447, 1], [4151, 9447, 1], [4152, 9447, 1], [4153, 9447, 1], [4154, 9447, 1], [4155, 9447, 1], [4156, 9447, 1], [4157, 9447, 1], [4158, 9447, 1], [4159, 9447, 1], [4160, 9447, 1], [4161, 9447, 1], [4162, 9447, 1], [4163, 9447, 1], [4164, 9447, 1], [4165, 9447, 1], [4166, 9447, 1], [4167, 9447, 1], [4168, 9447, 1], [4169, 9447, 1], [4170, 9447, 1], [4171, 9447, 1], [4172, 9447, 1], [4173, 9447, 1], [4174, 9447, 1], [4175, 9447, 1], [4176, 9447, 1], [4177, 9447, 1], [4178, 9447, 1], [4179, 9447, 1], [4180, 9447, 1], [4181, 9447, 1], [4182, 9447, 1], [4183, 9447, 1], [4184, 9447, 1], [4185, 9447, 1], [4186, 9447, 1], [4187, 9447, 1], [4188, 9447, 1], [4189, 9447, 1], [4190, 9447, 1], [4191, 9447, 1], [4192, 9447, 1], [4193, 9447, 1], [4194, 9447, 1], [4195, 9447, 1], [4196, 9447, 1], [4197, 9447, 1], [4198, 9447, 1], [4199, 9447, 1], [4200, 9447, 1], [4201, 9447, 1], [4202, 9447, 1], [4203, 9447, 1], [4204, 9447, 1], [4205, 9447, 1], [4206, 9447, 1], [4207, 9447, 1], [4208, 9447, 1], [4209, 9447, 1], [4210, 9447, 1], [4211, 9447, 1], [4212, 9447, 1], [4213, 9447, 1], [4214, 9447, 1], [4215, 9447, 1], [4216, 9447, 1], [4217, 9447, 1], [4218, 9447, 1], [4219, 9447, 1], [4220, 9447, 1], [4221, 9447, 1], [4222, 9447, 1], [4223, 9447, 1], [4224, 9447, 1], [4225, 9447, 1], [4226, 9447, 1], [4227, 9447, 1], [4228, 9447, 1], [4229, 9447, 1], [4230, 9447, 1], [4231, 9447, 1], [4232, 9447, 1], [4233, 9447, 1], [4234, 9447, 1], [4235, 9447, 1], [4236, 9447, 1], [4237, 9447, 1], [4238, 9447, 1], [4239, 9447, 1], [4240, 9447, 1], [4241, 9447, 1], [4242, 9447, 1], [4243, 9447, 1], [4244, 9447, 1], [4245, 9447, 1], [4246, 9447, 1], [4247, 9447, 1], [4248, 9447, 1], [4249, 9447, 1], [4250, 9447, 1], [4251, 9447, 1], [4252, 9447, 1], [4253, 9447, 1], [4254, 9447, 1], [4255, 9447, 1], [4256, 9447, 1], [4257, 9447, 1], [4258, 9447, 1], [4259, 9447, 1], [4260, 9447, 1], [4261, 9447, 1], [4262, 9447, 1], [4263, 9447, 1], [4264, 9455, 1], [4265, 9455, 1], [4266, 9455, 1], [4267, 9455, 1], [4268, 9455, 1], [4269, 9455, 1], [4270, 9455, 1], [4271, 9455, 1], [4272, 9455, 1], [4273, 9455, 1], [4274, 9455, 1], [4275, 9455, 1], [4276, 9455, 1], [4277, 9455, 1], [4278, 9455, 1], [4279, 9455, 1], [4280, 9455, 1], [4281, 9455, 1], [4282, 9455, 1], [4283, 9455, 1], [4284, 9455, 1], [4285, 9455, 1], [4286, 9455, 1], [4287, 9455, 1], [4288, 9455, 1], [4289, 9455, 1], [4290, 9455, 1], [4291, 9455, 1], [4292, 9455, 1], [4293, 9455, 1], [4294, 9455, 1], [4295, 9455, 1], [4296, 9455, 1], [4297, 9455, 1], [4298, 9455, 1], [4299, 9455, 1], [4300, 9455, 1], [4301, 9455, 1], [4302, 9455, 1], [4303, 9455, 1], [4304, 9455, 1], [4305, 9455, 1], [4306, 9455, 1], [4307, 9455, 1], [4308, 9455, 1], [4309, 9455, 1], [4310, 9455, 1], [4311, 9455, 1], [4312, 9455, 1], [4313, 9455, 1], [4314, 9455, 1], [4315, 9455, 1], [4316, 9455, 1], [4317, 9455, 1], [4318, 9455, 1], [4319, 9455, 1], [4320, 9455, 1], [4321, 9455, 1], [4322, 9455, 1], [4323, 9455, 1], [4324, 9455, 1], [4325, 9455, 1], [4326, 9455, 1], [4327, 9455, 1], [4328, 9455, 1], [4329, 9455, 1], [4330, 9455, 1], [4331, 9455, 1], [4332, 9455, 1], [4333, 9455, 1], [4334, 9455, 1], [4335, 9455, 1], [4336, 9455, 1], [4337, 9455, 1], [4338, 9455, 1], [4339, 9455, 1], [4340, 9455, 1], [4341, 9455, 1], [4342, 9455, 1], [4343, 9455, 1], [4344, 9455, 1], [4345, 9455, 1], [4346, 9455, 1], [4347, 9455, 1], [4348, 9455, 1], [4349, 9455, 1], [4350, 9455, 1], [4351, 9455, 1], [4352, 9455, 1], [4353, 9455, 1], [4354, 9455, 1], [4355, 9455, 1], [4356, 9455, 1], [4357, 9455, 1], [4358, 9455, 1], [4359, 9455, 1], [4360, 9455, 1], [4361, 9455, 1], [4362, 9455, 1], [4363, 9455, 1], [4364, 9455, 1], [4365, 9455, 1], [4366, 9455, 1], [4367, 9455, 1], [4368, 9455, 1], [4369, 9455, 1], [4370, 9455, 1], [4371, 9455, 1], [4372, 9455, 1], [4373, 9455, 1], [4374, 9455, 1], [4375, 9455, 1], [4376, 9455, 1], [4377, 9455, 1], [4378, 9455, 1], [4379, 9455, 1], [4380, 9455, 1], [4381, 9455, 1], [4382, 9455, 1], [4383, 9455, 1], [4384, 9455, 1], [4385, 9455, 1], [4386, 9455, 1], [4387, 9455, 1], [4388, 9455, 1], [4389, 9455, 1], [4390, 9455, 1], [4391, 9455, 1], [4392, 9455, 1], [4393, 9455, 1], [4394, 9455, 1], [4395, 9455, 1], [4396, 9455, 1], [4397, 9455, 1], [4398, 9455, 1], [4399, 9455, 1], [4400, 9455, 1], [4401, 9455, 1], [4402, 9455, 1], [4403, 9455, 1], [4404, 9458, 1], [4405, 9458, 1], [4406, 9458, 1], [4407, 9458, 1], [4408, 9458, 1], [4409, 9458, 1], [4410, 9458, 1], [4411, 9458, 1], [4412, 9458, 1], [4413, 9458, 1], [4414, 9458, 1], [4415, 9458, 1], [4416, 9458, 1], [4417, 9458, 1], [4418, 9458, 1], [4419, 9458, 1], [4420, 9458, 1], [4421, 9458, 1], [4422, 9458, 1], [4423, 9458, 1], [4424, 9458, 1], [4425, 9458, 1], [4426, 9458, 1], [4427, 9458, 1], [4428, 9458, 1], [4429, 9458, 1], [4430, 9458, 1], [4431, 9458, 1], [4432, 9458, 1], [4433, 9458, 1], [4434, 9458, 1], [4435, 9458, 1], [4436, 9458, 1], [4437, 9458, 1], [4438, 9458, 1], [4439, 9458, 1], [4440, 9458, 1], [4441, 9458, 1], [4442, 9458, 1], [4443, 9458, 1], [4444, 9458, 1], [4445, 9458, 1], [4446, 9458, 1], [4447, 9458, 1], [4448, 9458, 1], [4449, 9458, 1], [4450, 9458, 1], [4451, 9458, 1], [4452, 9458, 1], [4453, 9458, 1], [4454, 9458, 1], [4455, 9458, 1], [4456, 9458, 1], [4457, 9458, 1], [4458, 9458, 1], [4459, 9458, 1], [4460, 9458, 1], [4461, 9458, 1], [4462, 9458, 1], [4463, 9458, 1], [4464, 9458, 1], [4465, 9458, 1], [4466, 9458, 1], [4467, 9458, 1], [4468, 9458, 1], [4469, 9458, 1], [4470, 9458, 1], [4471, 9458, 1], [4472, 9458, 1], [4473, 9458, 1], [4474, 9458, 1], [4475, 9458, 1], [4476, 9458, 1], [4477, 9458, 1], [4478, 9458, 1], [4479, 9458, 1], [4480, 9458, 1], [4481, 9458, 1], [4482, 9458, 1], [4483, 9458, 1], [4484, 9458, 1], [4485, 9458, 1], [4486, 9458, 1], [4487, 9458, 1], [4488, 9458, 1], [4489, 9458, 1], [4490, 9458, 1], [4491, 9458, 1], [4492, 9458, 1], [4493, 9458, 1], [4494, 9458, 1], [4495, 9458, 1], [4496, 9458, 1], [4497, 9458, 1], [4498, 9458, 1], [4499, 9458, 1], [4500, 9458, 1], [4501, 9458, 1], [4502, 9458, 1], [4503, 9458, 1], [4504, 9458, 1], [4505, 9458, 1], [4506, 9458, 1], [4507, 9458, 1], [4508, 9458, 1], [4509, 9458, 1], [4510, 9458, 1], [4511, 9458, 1], [4512, 9458, 1], [4513, 9458, 1], [4514, 9458, 1], [4515, 9458, 1], [4516, 9458, 1], [4517, 9458, 1], [4518, 9458, 1], [4519, 9458, 1], [4520, 9458, 1], [4521, 9458, 1], [4522, 9458, 1], [4523, 9458, 1], [4524, 9458, 1], [4525, 9458, 1], [4526, 9458, 1], [4527, 9458, 1], [4528, 9458, 1], [4529, 9458, 1], [4530, 9458, 1], [4531, 9458, 1], [4532, 9458, 1], [4533, 9458, 1], [4534, 9458, 1], [4535, 9458, 1], [4536, 9458, 1], [4537, 9458, 1], [4538, 9458, 1], [4539, 9458, 1], [4540, 9458, 1], [4541, 9458, 1], [4542, 9458, 1], [4543, 9458, 1], [4544, 9445, 1], [4545, 9445, 1], [4546, 9445, 1], [4547, 9445, 1], [4548, 9445, 1], [4549, 9445, 1], [4550, 9445, 1], [4551, 9445, 1], [4552, 9445, 1], [4553, 9445, 1], [4554, 9445, 1], [4555, 9445, 1], [4556, 9445, 1], [4557, 9445, 1], [4558, 9445, 1], [4559, 9445, 1], [4560, 9445, 1], [4561, 9445, 1], [4562, 9445, 1], [4563, 9445, 1], [4564, 9445, 1], [4565, 9445, 1], [4566, 9445, 1], [4567, 9445, 1], [4568, 9445, 1], [4569, 9445, 1], [4570, 9445, 1], [4571, 9445, 1], [4572, 9445, 1], [4573, 9445, 1], [4574, 9445, 1], [4575, 9445, 1], [4576, 9445, 1], [4577, 9445, 1], [4578, 9445, 1], [4579, 9445, 1], [4580, 9445, 1], [4581, 9445, 1], [4582, 9445, 1], [4583, 9445, 1], [4584, 9445, 1], [4585, 9445, 1], [4586, 9445, 1], [4587, 9445, 1], [4588, 9445, 1], [4589, 9445, 1], [4590, 9445, 1], [4591, 9445, 1], [4592, 9445, 1], [4593, 9445, 1], [4594, 9445, 1], [4595, 9445, 1], [4596, 9445, 1], [4597, 9445, 1], [4598, 9445, 1], [4599, 9445, 1], [4600, 9445, 1], [4601, 9445, 1], [4602, 9445, 1], [4603, 9445, 1], [4604, 9445, 1], [4605, 9445, 1], [4606, 9445, 1], [4607, 9445, 1], [4608, 9445, 1], [4609, 9445, 1], [4610, 9445, 1], [4611, 9445, 1], [4612, 9445, 1], [4613, 9445, 1], [4614, 9445, 1], [4615, 9445, 1], [4616, 9445, 1], [4617, 9445, 1], [4618, 9445, 1], [4619, 9445, 1], [4620, 9445, 1], [4621, 9445, 1], [4622, 9445, 1], [4623, 9445, 1], [4624, 9445, 1], [4625, 9445, 1], [4626, 9445, 1], [4627, 9445, 1], [4628, 9445, 1], [4629, 9445, 1], [4630, 9445, 1], [4631, 9445, 1], [4632, 9445, 1], [4633, 9445, 1], [4634, 9445, 1], [4635, 9445, 1], [4636, 9445, 1], [4637, 9445, 1], [4638, 9445, 1], [4639, 9445, 1], [4640, 9445, 1], [4641, 9445, 1], [4642, 9445, 1], [4643, 9445, 1], [4644, 9445, 1], [4645, 9445, 1], [4646, 9445, 1], [4647, 9445, 1], [4648, 9445, 1], [4649, 9445, 1], [4650, 9445, 1], [4651, 9445, 1], [4652, 9445, 1], [4653, 9445, 1], [4654, 9445, 1], [4655, 9445, 1], [4656, 9445, 1], [4657, 9445, 1], [4658, 9445, 1], [4659, 9445, 1], [4660, 9445, 1], [4661, 9445, 1], [4662, 9445, 1], [4663, 9445, 1], [4664, 9445, 1], [4665, 9445, 1], [4666, 9445, 1], [4667, 9445, 1], [4668, 9445, 1], [4669, 9445, 1], [4670, 9445, 1], [4671, 9445, 1], [4672, 9445, 1], [4673, 9445, 1], [4674, 9445, 1], [4675, 9445, 1], [4676, 9445, 1], [4677, 9445, 1], [4678, 9445, 1], [4679, 9445, 1], [4680, 9445, 1], [4681, 9445, 1], [4682, 9445, 1], [4683, 9445, 1], [4684, 9464, 1], [4685, 9464, 1], [4686, 9464, 1], [4687, 9464, 1], [4688, 9464, 1], [4689, 9464, 1], [4690, 9464, 1], [4691, 9464, 1], [4692, 9464, 1], [4693, 9464, 1], [4694, 9464, 1], [4695, 9464, 1], [4696, 9464, 1], [4697, 9464, 1], [4698, 9464, 1], [4699, 9464, 1], [4700, 9464, 1], [4701, 9464, 1], [4702, 9464, 1], [4703, 9464, 1], [4704, 9464, 1], [4705, 9464, 1], [4706, 9464, 1], [4707, 9464, 1], [4708, 9464, 1], [4709, 9464, 1], [4710, 9464, 1], [4711, 9464, 1], [4712, 9464, 1], [4713, 9464, 1], [4714, 9464, 1], [4715, 9464, 1], [4716, 9464, 1], [4717, 9464, 1], [4718, 9464, 1], [4719, 9464, 1], [4720, 9464, 1], [4721, 9464, 1], [4722, 9464, 1], [4723, 9464, 1], [4724, 9464, 1], [4725, 9464, 1], [4726, 9464, 1], [4727, 9464, 1], [4728, 9464, 1], [4729, 9464, 1], [4730, 9464, 1], [4731, 9464, 1], [4732, 9464, 1], [4733, 9464, 1], [4734, 9464, 1], [4735, 9464, 1], [4736, 9464, 1], [4737, 9464, 1], [4738, 9464, 1], [4739, 9464, 1], [4740, 9464, 1], [4741, 9464, 1], [4742, 9464, 1], [4743, 9464, 1], [4744, 9464, 1], [4745, 9464, 1], [4746, 9464, 1], [4747, 9464, 1], [4748, 9464, 1], [4749, 9464, 1], [4750, 9464, 1], [4751, 9464, 1], [4752, 9464, 1], [4753, 9464, 1], [4754, 9464, 1], [4755, 9464, 1], [4756, 9464, 1], [4757, 9464, 1], [4758, 9464, 1], [4759, 9464, 1], [4760, 9464, 1], [4761, 9464, 1], [4762, 9464, 1], [4763, 9464, 1], [4764, 9464, 1], [4765, 9464, 1], [4766, 9464, 1], [4767, 9464, 1], [4768, 9464, 1], [4769, 9464, 1], [4770, 9464, 1], [4771, 9464, 1], [4772, 9464, 1], [4773, 9464, 1], [4774, 9464, 1], [4775, 9464, 1], [4776, 9464, 1], [4777, 9464, 1], [4778, 9464, 1], [4779, 9464, 1], [4780, 9464, 1], [4781, 9464, 1], [4782, 9464, 1], [4783, 9464, 1], [4784, 9464, 1], [4785, 9464, 1], [4786, 9464, 1], [4787, 9464, 1], [4788, 9464, 1], [4789, 9464, 1], [4790, 9464, 1], [4791, 9464, 1], [4792, 9464, 1], [4793, 9464, 1], [4794, 9464, 1], [4795, 9464, 1], [4796, 9464, 1], [4797, 9464, 1], [4798, 9464, 1], [4799, 9464, 1], [4800, 9464, 1], [4801, 9464, 1], [4802, 9464, 1], [4803, 9464, 1], [4804, 9464, 1], [4805, 9464, 1], [4806, 9464, 1], [4807, 9464, 1], [4808, 9464, 1], [4809, 9464, 1], [4810, 9464, 1], [4811, 9464, 1], [4812, 9464, 1], [4813, 9464, 1], [4814, 9464, 1], [4815, 9464, 1], [4816, 9464, 1], [4817, 9464, 1], [4818, 9464, 1], [4819, 9464, 1], [4820, 9464, 1], [4821, 9464, 1], [4822, 9464, 1], [4823, 9464, 1], [4824, 9464, 1], [4825, 9464, 1], [4826, 9464, 1], [4827, 9464, 1], [4828, 9464, 1], [4829, 9464, 1], [4830, 9464, 1], [4831, 9464, 1], [4832, 9464, 1], [4833, 9464, 1], [4834, 9464, 1], [4835, 9464, 1], [4836, 9464, 1], [4837, 9464, 1], [4838, 9464, 1], [4839, 9464, 1], [4840, 9464, 1], [4841, 9464, 1], [4842, 9464, 1], [4843, 9464, 1], [4844, 9464, 1], [4845, 9464, 1], [4846, 9464, 1], [4847, 9464, 1], [4848, 9464, 1], [4849, 9464, 1], [4850, 9464, 1], [4851, 9464, 1], [4852, 9464, 1], [4853, 9464, 1], [4854, 9464, 1], [4855, 9464, 1], [4856, 9464, 1], [4857, 9464, 1], [4858, 9464, 1], [4859, 9464, 1], [4860, 9464, 1], [4861, 9464, 1], [4862, 9464, 1], [4863, 9464, 1], [4864, 9464, 1], [4865, 9464, 1], [4866, 9464, 1], [4867, 9464, 1], [4868, 9464, 1], [4869, 9464, 1], [4870, 9464, 1], [4871, 9464, 1], [4872, 9464, 1], [4873, 9464, 1], [4874, 9464, 1], [4875, 9464, 1], [4876, 9464, 1], [4877, 9464, 1], [4878, 9464, 1], [4879, 9464, 1], [4880, 9464, 1], [4881, 9464, 1], [4882, 9464, 1], [4883, 9464, 1], [4884, 9464, 1], [4885, 9464, 1], [4886, 9464, 1], [4887, 9464, 1], [4888, 9464, 1], [4889, 9464, 1], [4890, 9464, 1], [4891, 9464, 1], [4892, 9464, 1], [4893, 9464, 1], [4894, 9464, 1], [4895, 9464, 1], [4896, 9464, 1], [4897, 9464, 1], [4898, 9464, 1], [4899, 9464, 1], [4900, 9464, 1], [4901, 9464, 1], [4902, 9464, 1], [4903, 9464, 1], [4904, 9464, 1], [4905, 9464, 1], [4906, 9464, 1], [4907, 9464, 1], [4908, 9464, 1], [4909, 9464, 1], [4910, 9464, 1], [4911, 9464, 1], [4912, 9464, 1], [4913, 9464, 1], [4914, 9464, 1], [4915, 9464, 1], [4916, 9464, 1], [4917, 9464, 1], [4918, 9464, 1], [4919, 9464, 1], [4920, 9464, 1], [4921, 9464, 1], [4922, 9464, 1], [4923, 9464, 1], [4924, 9464, 1], [4925, 9464, 1], [4926, 9464, 1], [4927, 9464, 1], [4928, 9464, 1], [4929, 9464, 1], [4930, 9464, 1], [4931, 9464, 1], [4932, 9464, 1], [4933, 9464, 1], [4934, 9464, 1], [4935, 9464, 1], [4936, 9464, 1], [4937, 9464, 1], [4938, 9464, 1], [4939, 9464, 1], [4940, 9464, 1], [4941, 9464, 1], [4942, 9464, 1], [4943, 9464, 1], [4944, 9464, 1], [4945, 9464, 1], [4946, 9464, 1], [4947, 9464, 1], [4948, 9464, 1], [4949, 9464, 1], [4950, 9464, 1], [4951, 9464, 1], [4952, 9464, 1], [4953, 9464, 1], [4954, 9464, 1], [4955, 9464, 1], [4956, 9464, 1], [4957, 9464, 1], [4958, 9464, 1], [4959, 9464, 1], [4960, 9464, 1], [4961, 9464, 1], [4962, 9464, 1], [4963, 9464, 1], [4964, 9445, 1], [4965, 9445, 1], [4966, 9445, 1], [4967, 9445, 1], [4968, 9445, 1], [4969, 9445, 1], [4970, 9445, 1], [4971, 9445, 1], [4972, 9445, 1], [4973, 9445, 1], [4974, 9445, 1], [4975, 9445, 1], [4976, 9445, 1], [4977, 9445, 1], [4978, 9445, 1], [4979, 9445, 1], [4980, 9445, 1], [4981, 9445, 1], [4982, 9445, 1], [4983, 9445, 1], [4984, 9445, 1], [4985, 9445, 1], [4986, 9445, 1], [4987, 9445, 1], [4988, 9445, 1], [4989, 9445, 1], [4990, 9445, 1], [4991, 9445, 1], [4992, 9445, 1], [4993, 9445, 1], [4994, 9445, 1], [4995, 9445, 1], [4996, 9445, 1], [4997, 9445, 1], [4998, 9445, 1], [4999, 9445, 1], [5000, 9445, 1], [5001, 9445, 1], [5002, 9445, 1], [5003, 9445, 1], [5004, 9445, 1], [5005, 9445, 1], [5006, 9445, 1], [5007, 9445, 1], [5008, 9445, 1], [5009, 9445, 1], [5010, 9445, 1], [5011, 9445, 1], [5012, 9445, 1], [5013, 9445, 1], [5014, 9445, 1], [5015, 9445, 1], [5016, 9445, 1], [5017, 9445, 1], [5018, 9445, 1], [5019, 9445, 1], [5020, 9445, 1], [5021, 9445, 1], [5022, 9445, 1], [5023, 9445, 1], [5024, 9445, 1], [5025, 9445, 1], [5026, 9445, 1], [5027, 9445, 1], [5028, 9445, 1], [5029, 9445, 1], [5030, 9445, 1], [5031, 9445, 1], [5032, 9445, 1], [5033, 9445, 1], [5034, 9445, 1], [5035, 9445, 1], [5036, 9445, 1], [5037, 9445, 1], [5038, 9445, 1], [5039, 9445, 1], [5040, 9445, 1], [5041, 9445, 1], [5042, 9445, 1], [5043, 9445, 1], [5044, 9445, 1], [5045, 9445, 1], [5046, 9445, 1], [5047, 9445, 1], [5048, 9445, 1], [5049, 9445, 1], [5050, 9445, 1], [5051, 9445, 1], [5052, 9445, 1], [5053, 9445, 1], [5054, 9445, 1], [5055, 9445, 1], [5056, 9445, 1], [5057, 9445, 1], [5058, 9445, 1], [5059, 9445, 1], [5060, 9445, 1], [5061, 9445, 1], [5062, 9445, 1], [5063, 9445, 1], [5064, 9445, 1], [5065, 9445, 1], [5066, 9445, 1], [5067, 9445, 1], [5068, 9445, 1], [5069, 9445, 1], [5070, 9445, 1], [5071, 9445, 1], [5072, 9445, 1], [5073, 9445, 1], [5074, 9445, 1], [5075, 9445, 1], [5076, 9445, 1], [5077, 9445, 1], [5078, 9445, 1], [5079, 9445, 1], [5080, 9445, 1], [5081, 9445, 1], [5082, 9445, 1], [5083, 9445, 1], [5084, 9445, 1], [5085, 9445, 1], [5086, 9445, 1], [5087, 9445, 1], [5088, 9445, 1], [5089, 9445, 1], [5090, 9445, 1], [5091, 9445, 1], [5092, 9445, 1], [5093, 9445, 1], [5094, 9445, 1], [5095, 9445, 1], [5096, 9445, 1], [5097, 9445, 1], [5098, 9445, 1], [5099, 9445, 1], [5100, 9445, 1], [5101, 9445, 1], [5102, 9445, 1], [5103, 9445, 1], [5104, 9458, 1], [5105, 9458, 1], [5106, 9458, 1], [5107, 9458, 1], [5108, 9458, 1], [5109, 9458, 1], [5110, 9458, 1], [5111, 9458, 1], [5112, 9458, 1], [5113, 9458, 1], [5114, 9458, 1], [5115, 9458, 1], [5116, 9458, 1], [5117, 9458, 1], [5118, 9458, 1], [5119, 9458, 1], [5120, 9458, 1], [5121, 9458, 1], [5122, 9458, 1], [5123, 9458, 1], [5124, 9458, 1], [5125, 9458, 1], [5126, 9458, 1], [5127, 9458, 1], [5128, 9458, 1], [5129, 9458, 1], [5130, 9458, 1], [5131, 9458, 1], [5132, 9458, 1], [5133, 9458, 1], [5134, 9458, 1], [5135, 9458, 1], [5136, 9458, 1], [5137, 9458, 1], [5138, 9458, 1], [5139, 9458, 1], [5140, 9458, 1], [5141, 9458, 1], [5142, 9458, 1], [5143, 9458, 1], [5144, 9458, 1], [5145, 9458, 1], [5146, 9458, 1], [5147, 9458, 1], [5148, 9458, 1], [5149, 9458, 1], [5150, 9458, 1], [5151, 9458, 1], [5152, 9458, 1], [5153, 9458, 1], [5154, 9458, 1], [5155, 9458, 1], [5156, 9458, 1], [5157, 9458, 1], [5158, 9458, 1], [5159, 9458, 1], [5160, 9458, 1], [5161, 9458, 1], [5162, 9458, 1], [5163, 9458, 1], [5164, 9458, 1], [5165, 9458, 1], [5166, 9458, 1], [5167, 9458, 1], [5168, 9458, 1], [5169, 9458, 1], [5170, 9458, 1], [5171, 9458, 1], [5172, 9458, 1], [5173, 9458, 1], [5174, 9458, 1], [5175, 9458, 1], [5176, 9458, 1], [5177, 9458, 1], [5178, 9458, 1], [5179, 9458, 1], [5180, 9458, 1], [5181, 9458, 1], [5182, 9458, 1], [5183, 9458, 1], [5184, 9458, 1], [5185, 9458, 1], [5186, 9458, 1], [5187, 9458, 1], [5188, 9458, 1], [5189, 9458, 1], [5190, 9458, 1], [5191, 9458, 1], [5192, 9458, 1], [5193, 9458, 1], [5194, 9458, 1], [5195, 9458, 1], [5196, 9458, 1], [5197, 9458, 1], [5198, 9458, 1], [5199, 9458, 1], [5200, 9458, 1], [5201, 9458, 1], [5202, 9458, 1], [5203, 9458, 1], [5204, 9458, 1], [5205, 9458, 1], [5206, 9458, 1], [5207, 9458, 1], [5208, 9458, 1], [5209, 9458, 1], [5210, 9458, 1], [5211, 9458, 1], [5212, 9458, 1], [5213, 9458, 1], [5214, 9458, 1], [5215, 9458, 1], [5216, 9458, 1], [5217, 9458, 1], [5218, 9458, 1], [5219, 9458, 1], [5220, 9458, 1], [5221, 9458, 1], [5222, 9458, 1], [5223, 9458, 1], [5224, 9458, 1], [5225, 9458, 1], [5226, 9458, 1], [5227, 9458, 1], [5228, 9458, 1], [5229, 9458, 1], [5230, 9458, 1], [5231, 9458, 1], [5232, 9458, 1], [5233, 9458, 1], [5234, 9458, 1], [5235, 9458, 1], [5236, 9458, 1], [5237, 9458, 1], [5238, 9458, 1], [5239, 9458, 1], [5240, 9458, 1], [5241, 9458, 1], [5242, 9458, 1], [5243, 9458, 1], [5244, 9460, 1], [5245, 9460, 1], [5246, 9460, 1], [5247, 9460, 1], [5248, 9460, 1], [5249, 9460, 1], [5250, 9460, 1], [5251, 9460, 1], [5252, 9460, 1], [5253, 9460, 1], [5254, 9460, 1], [5255, 9460, 1], [5256, 9460, 1], [5257, 9460, 1], [5258, 9460, 1], [5259, 9460, 1], [5260, 9460, 1], [5261, 9460, 1], [5262, 9460, 1], [5263, 9460, 1], [5264, 9460, 1], [5265, 9460, 1], [5266, 9460, 1], [5267, 9460, 1], [5268, 9460, 1], [5269, 9460, 1], [5270, 9460, 1], [5271, 9460, 1], [5272, 9460, 1], [5273, 9460, 1], [5274, 9460, 1], [5275, 9460, 1], [5276, 9460, 1], [5277, 9460, 1], [5278, 9460, 1], [5279, 9460, 1], [5280, 9460, 1], [5281, 9460, 1], [5282, 9460, 1], [5283, 9460, 1], [5284, 9460, 1], [5285, 9460, 1], [5286, 9460, 1], [5287, 9460, 1], [5288, 9460, 1], [5289, 9460, 1], [5290, 9460, 1], [5291, 9460, 1], [5292, 9460, 1], [5293, 9460, 1], [5294, 9460, 1], [5295, 9460, 1], [5296, 9460, 1], [5297, 9460, 1], [5298, 9460, 1], [5299, 9460, 1], [5300, 9460, 1], [5301, 9460, 1], [5302, 9460, 1], [5303, 9460, 1], [5304, 9460, 1], [5305, 9460, 1], [5306, 9460, 1], [5307, 9460, 1], [5308, 9460, 1], [5309, 9460, 1], [5310, 9460, 1], [5311, 9460, 1], [5312, 9460, 1], [5313, 9460, 1], [5314, 9460, 1], [5315, 9460, 1], [5316, 9460, 1], [5317, 9460, 1], [5318, 9460, 1], [5319, 9460, 1], [5320, 9460, 1], [5321, 9460, 1], [5322, 9460, 1], [5323, 9460, 1], [5324, 9460, 1], [5325, 9460, 1], [5326, 9460, 1], [5327, 9460, 1], [5328, 9460, 1], [5329, 9460, 1], [5330, 9460, 1], [5331, 9460, 1], [5332, 9460, 1], [5333, 9460, 1], [5334, 9460, 1], [5335, 9460, 1], [5336, 9460, 1], [5337, 9460, 1], [5338, 9460, 1], [5339, 9460, 1], [5340, 9460, 1], [5341, 9460, 1], [5342, 9460, 1], [5343, 9460, 1], [5344, 9460, 1], [5345, 9460, 1], [5346, 9460, 1], [5347, 9460, 1], [5348, 9460, 1], [5349, 9460, 1], [5350, 9460, 1], [5351, 9460, 1], [5352, 9460, 1], [5353, 9460, 1], [5354, 9460, 1], [5355, 9460, 1], [5356, 9460, 1], [5357, 9460, 1], [5358, 9460, 1], [5359, 9460, 1], [5360, 9460, 1], [5361, 9460, 1], [5362, 9460, 1], [5363, 9460, 1], [5364, 9460, 1], [5365, 9460, 1], [5366, 9460, 1], [5367, 9460, 1], [5368, 9460, 1], [5369, 9460, 1], [5370, 9460, 1], [5371, 9460, 1], [5372, 9460, 1], [5373, 9460, 1], [5374, 9460, 1], [5375, 9460, 1], [5376, 9460, 1], [5377, 9460, 1], [5378, 9460, 1], [5379, 9460, 1], [5380, 9460, 1], [5381, 9460, 1], [5382, 9460, 1], [5383, 9460, 1], [5384, 9448, 1], [5385, 9448, 1], [5386, 9448, 1], [5387, 9448, 1], [5388, 9448, 1], [5389, 9448, 1], [5390, 9448, 1], [5391, 9448, 1], [5392, 9448, 1], [5393, 9448, 1], [5394, 9448, 1], [5395, 9448, 1], [5396, 9448, 1], [5397, 9448, 1], [5398, 9448, 1], [5399, 9448, 1], [5400, 9448, 1], [5401, 9448, 1], [5402, 9448, 1], [5403, 9448, 1], [5404, 9448, 1], [5405, 9448, 1], [5406, 9448, 1], [5407, 9448, 1], [5408, 9448, 1], [5409, 9448, 1], [5410, 9448, 1], [5411, 9448, 1], [5412, 9448, 1], [5413, 9448, 1], [5414, 9448, 1], [5415, 9448, 1], [5416, 9448, 1], [5417, 9448, 1], [5418, 9448, 1], [5419, 9448, 1], [5420, 9448, 1], [5421, 9448, 1], [5422, 9448, 1], [5423, 9448, 1], [5424, 9448, 1], [5425, 9448, 1], [5426, 9448, 1], [5427, 9448, 1], [5428, 9448, 1], [5429, 9448, 1], [5430, 9448, 1], [5431, 9448, 1], [5432, 9448, 1], [5433, 9448, 1], [5434, 9448, 1], [5435, 9448, 1], [5436, 9448, 1], [5437, 9448, 1], [5438, 9448, 1], [5439, 9448, 1], [5440, 9448, 1], [5441, 9448, 1], [5442, 9448, 1], [5443, 9448, 1], [5444, 9448, 1], [5445, 9448, 1], [5446, 9448, 1], [5447, 9448, 1], [5448, 9448, 1], [5449, 9448, 1], [5450, 9448, 1], [5451, 9448, 1], [5452, 9448, 1], [5453, 9448, 1], [5454, 9448, 1], [5455, 9448, 1], [5456, 9448, 1], [5457, 9448, 1], [5458, 9448, 1], [5459, 9448, 1], [5460, 9448, 1], [5461, 9448, 1], [5462, 9448, 1], [5463, 9448, 1], [5464, 9448, 1], [5465, 9448, 1], [5466, 9448, 1], [5467, 9448, 1], [5468, 9448, 1], [5469, 9448, 1], [5470, 9448, 1], [5471, 9448, 1], [5472, 9448, 1], [5473, 9448, 1], [5474, 9448, 1], [5475, 9448, 1], [5476, 9448, 1], [5477, 9448, 1], [5478, 9448, 1], [5479, 9448, 1], [5480, 9448, 1], [5481, 9448, 1], [5482, 9448, 1], [5483, 9448, 1], [5484, 9448, 1], [5485, 9448, 1], [5486, 9448, 1], [5487, 9448, 1], [5488, 9448, 1], [5489, 9448, 1], [5490, 9448, 1], [5491, 9448, 1], [5492, 9448, 1], [5493, 9448, 1], [5494, 9448, 1], [5495, 9448, 1], [5496, 9448, 1], [5497, 9448, 1], [5498, 9448, 1], [5499, 9448, 1], [5500, 9448, 1], [5501, 9448, 1], [5502, 9448, 1], [5503, 9448, 1], [5504, 9448, 1], [5505, 9448, 1], [5506, 9448, 1], [5507, 9448, 1], [5508, 9448, 1], [5509, 9448, 1], [5510, 9448, 1], [5511, 9448, 1], [5512, 9448, 1], [5513, 9448, 1], [5514, 9448, 1], [5515, 9448, 1], [5516, 9448, 1], [5517, 9448, 1], [5518, 9448, 1], [5519, 9448, 1], [5520, 9448, 1], [5521, 9448, 1], [5522, 9448, 1], [5523, 9448, 1], [5524, 9471, 1], [5525, 9471, 1], [5526, 9471, 1], [5527, 9471, 1], [5528, 9471, 1], [5529, 9471, 1], [5530, 9471, 1], [5531, 9471, 1], [5532, 9471, 1], [5533, 9471, 1], [5534, 9471, 1], [5535, 9471, 1], [5536, 9471, 1], [5537, 9471, 1], [5538, 9471, 1], [5539, 9471, 1], [5540, 9471, 1], [5541, 9471, 1], [5542, 9471, 1], [5543, 9471, 1], [5544, 9471, 1], [5545, 9471, 1], [5546, 9471, 1], [5547, 9471, 1], [5548, 9471, 1], [5549, 9471, 1], [5550, 9471, 1], [5551, 9471, 1], [5552, 9471, 1], [5553, 9471, 1], [5554, 9471, 1], [5555, 9471, 1], [5556, 9471, 1], [5557, 9471, 1], [5558, 9471, 1], [5559, 9471, 1], [5560, 9471, 1], [5561, 9471, 1], [5562, 9471, 1], [5563, 9471, 1], [5564, 9471, 1], [5565, 9471, 1], [5566, 9471, 1], [5567, 9471, 1], [5568, 9471, 1], [5569, 9471, 1], [5570, 9471, 1], [5571, 9471, 1], [5572, 9471, 1], [5573, 9471, 1], [5574, 9471, 1], [5575, 9471, 1], [5576, 9471, 1], [5577, 9471, 1], [5578, 9471, 1], [5579, 9471, 1], [5580, 9471, 1], [5581, 9471, 1], [5582, 9471, 1], [5583, 9471, 1], [5584, 9471, 1], [5585, 9471, 1], [5586, 9471, 1], [5587, 9471, 1], [5588, 9471, 1], [5589, 9471, 1], [5590, 9471, 1], [5591, 9471, 1], [5592, 9471, 1], [5593, 9471, 1], [5594, 9471, 1], [5595, 9471, 1], [5596, 9471, 1], [5597, 9471, 1], [5598, 9471, 1], [5599, 9471, 1], [5600, 9471, 1], [5601, 9471, 1], [5602, 9471, 1], [5603, 9471, 1], [5604, 9471, 1], [5605, 9471, 1], [5606, 9471, 1], [5607, 9471, 1], [5608, 9471, 1], [5609, 9471, 1], [5610, 9471, 1], [5611, 9471, 1], [5612, 9471, 1], [5613, 9471, 1], [5614, 9471, 1], [5615, 9471, 1], [5616, 9471, 1], [5617, 9471, 1], [5618, 9471, 1], [5619, 9471, 1], [5620, 9471, 1], [5621, 9471, 1], [5622, 9471, 1], [5623, 9471, 1], [5624, 9471, 1], [5625, 9471, 1], [5626, 9471, 1], [5627, 9471, 1], [5628, 9471, 1], [5629, 9471, 1], [5630, 9471, 1], [5631, 9471, 1], [5632, 9471, 1], [5633, 9471, 1], [5634, 9471, 1], [5635, 9471, 1], [5636, 9471, 1], [5637, 9471, 1], [5638, 9471, 1], [5639, 9471, 1], [5640, 9471, 1], [5641, 9471, 1], [5642, 9471, 1], [5643, 9471, 1], [5644, 9471, 1], [5645, 9471, 1], [5646, 9471, 1], [5647, 9471, 1], [5648, 9471, 1], [5649, 9471, 1], [5650, 9471, 1], [5651, 9471, 1], [5652, 9471, 1], [5653, 9471, 1], [5654, 9471, 1], [5655, 9471, 1], [5656, 9471, 1], [5657, 9471, 1], [5658, 9471, 1], [5659, 9471, 1], [5660, 9471, 1], [5661, 9471, 1], [5662, 9471, 1], [5663, 9471, 1], [5664, 9471, 1], [5665, 9471, 1], [5666, 9471, 1], [5667, 9471, 1], [5668, 9471, 1], [5669, 9471, 1], [5670, 9471, 1], [5671, 9471, 1], [5672, 9471, 1], [5673, 9471, 1], [5674, 9471, 1], [5675, 9471, 1], [5676, 9471, 1], [5677, 9471, 1], [5678, 9471, 1], [5679, 9471, 1], [5680, 9471, 1], [5681, 9471, 1], [5682, 9471, 1], [5683, 9471, 1], [5684, 9471, 1], [5685, 9471, 1], [5686, 9471, 1], [5687, 9471, 1], [5688, 9471, 1], [5689, 9471, 1], [5690, 9471, 1], [5691, 9471, 1], [5692, 9471, 1], [5693, 9471, 1], [5694, 9471, 1], [5695, 9471, 1], [5696, 9471, 1], [5697, 9471, 1], [5698, 9471, 1], [5699, 9471, 1], [5700, 9471, 1], [5701, 9471, 1], [5702, 9471, 1], [5703, 9471, 1], [5704, 9471, 1], [5705, 9471, 1], [5706, 9471, 1], [5707, 9471, 1], [5708, 9471, 1], [5709, 9471, 1], [5710, 9471, 1], [5711, 9471, 1], [5712, 9471, 1], [5713, 9471, 1], [5714, 9471, 1], [5715, 9471, 1], [5716, 9471, 1], [5717, 9471, 1], [5718, 9471, 1], [5719, 9471, 1], [5720, 9471, 1], [5721, 9471, 1], [5722, 9471, 1], [5723, 9471, 1], [5724, 9471, 1], [5725, 9471, 1], [5726, 9471, 1], [5727, 9471, 1], [5728, 9471, 1], [5729, 9471, 1], [5730, 9471, 1], [5731, 9471, 1], [5732, 9471, 1], [5733, 9471, 1], [5734, 9471, 1], [5735, 9471, 1], [5736, 9471, 1], [5737, 9471, 1], [5738, 9471, 1], [5739, 9471, 1], [5740, 9471, 1], [5741, 9471, 1], [5742, 9471, 1], [5743, 9471, 1], [5744, 9471, 1], [5745, 9471, 1], [5746, 9471, 1], [5747, 9471, 1], [5748, 9471, 1], [5749, 9471, 1], [5750, 9471, 1], [5751, 9471, 1], [5752, 9471, 1], [5753, 9471, 1], [5754, 9471, 1], [5755, 9471, 1], [5756, 9471, 1], [5757, 9471, 1], [5758, 9471, 1], [5759, 9471, 1], [5760, 9471, 1], [5761, 9471, 1], [5762, 9471, 1], [5763, 9471, 1], [5764, 9471, 1], [5765, 9471, 1], [5766, 9471, 1], [5767, 9471, 1], [5768, 9471, 1], [5769, 9471, 1], [5770, 9471, 1], [5771, 9471, 1], [5772, 9471, 1], [5773, 9471, 1], [5774, 9471, 1], [5775, 9471, 1], [5776, 9471, 1], [5777, 9471, 1], [5778, 9471, 1], [5779, 9471, 1], [5780, 9471, 1], [5781, 9471, 1], [5782, 9471, 1], [5783, 9471, 1], [5784, 9471, 1], [5785, 9471, 1], [5786, 9471, 1], [5787, 9471, 1], [5788, 9471, 1], [5789, 9471, 1], [5790, 9471, 1], [5791, 9471, 1], [5792, 9471, 1], [5793, 9471, 1], [5794, 9471, 1], [5795, 9471, 1], [5796, 9471, 1], [5797, 9471, 1], [5798, 9471, 1], [5799, 9471, 1], [5800, 9471, 1], [5801, 9471, 1], [5802, 9471, 1], [5803, 9471, 1], [5804, 9448, 1], [5805, 9448, 1], [5806, 9448, 1], [5807, 9448, 1], [5808, 9448, 1], [5809, 9448, 1], [5810, 9448, 1], [5811, 9448, 1], [5812, 9448, 1], [5813, 9448, 1], [5814, 9448, 1], [5815, 9448, 1], [5816, 9448, 1], [5817, 9448, 1], [5818, 9448, 1], [5819, 9448, 1], [5820, 9448, 1], [5821, 9448, 1], [5822, 9448, 1], [5823, 9448, 1], [5824, 9448, 1], [5825, 9448, 1], [5826, 9448, 1], [5827, 9448, 1], [5828, 9448, 1], [5829, 9448, 1], [5830, 9448, 1], [5831, 9448, 1], [5832, 9448, 1], [5833, 9448, 1], [5834, 9448, 1], [5835, 9448, 1], [5836, 9448, 1], [5837, 9448, 1], [5838, 9448, 1], [5839, 9448, 1], [5840, 9448, 1], [5841, 9448, 1], [5842, 9448, 1], [5843, 9448, 1], [5844, 9448, 1], [5845, 9448, 1], [5846, 9448, 1], [5847, 9448, 1], [5848, 9448, 1], [5849, 9448, 1], [5850, 9448, 1], [5851, 9448, 1], [5852, 9448, 1], [5853, 9448, 1], [5854, 9448, 1], [5855, 9448, 1], [5856, 9448, 1], [5857, 9448, 1], [5858, 9448, 1], [5859, 9448, 1], [5860, 9448, 1], [5861, 9448, 1], [5862, 9448, 1], [5863, 9448, 1], [5864, 9448, 1], [5865, 9448, 1], [5866, 9448, 1], [5867, 9448, 1], [5868, 9448, 1], [5869, 9448, 1], [5870, 9448, 1], [5871, 9448, 1], [5872, 9448, 1], [5873, 9448, 1], [5874, 9448, 1], [5875, 9448, 1], [5876, 9448, 1], [5877, 9448, 1], [5878, 9448, 1], [5879, 9448, 1], [5880, 9448, 1], [5881, 9448, 1], [5882, 9448, 1], [5883, 9448, 1], [5884, 9448, 1], [5885, 9448, 1], [5886, 9448, 1], [5887, 9448, 1], [5888, 9448, 1], [5889, 9448, 1], [5890, 9448, 1], [5891, 9448, 1], [5892, 9448, 1], [5893, 9448, 1], [5894, 9448, 1], [5895, 9448, 1], [5896, 9448, 1], [5897, 9448, 1], [5898, 9448, 1], [5899, 9448, 1], [5900, 9448, 1], [5901, 9448, 1], [5902, 9448, 1], [5903, 9448, 1], [5904, 9448, 1], [5905, 9448, 1], [5906, 9448, 1], [5907, 9448, 1], [5908, 9448, 1], [5909, 9448, 1], [5910, 9448, 1], [5911, 9448, 1], [5912, 9448, 1], [5913, 9448, 1], [5914, 9448, 1], [5915, 9448, 1], [5916, 9448, 1], [5917, 9448, 1], [5918, 9448, 1], [5919, 9448, 1], [5920, 9448, 1], [5921, 9448, 1], [5922, 9448, 1], [5923, 9448, 1], [5924, 9448, 1], [5925, 9448, 1], [5926, 9448, 1], [5927, 9448, 1], [5928, 9448, 1], [5929, 9448, 1], [5930, 9448, 1], [5931, 9448, 1], [5932, 9448, 1], [5933, 9448, 1], [5934, 9448, 1], [5935, 9448, 1], [5936, 9448, 1], [5937, 9448, 1], [5938, 9448, 1], [5939, 9448, 1], [5940, 9448, 1], [5941, 9448, 1], [5942, 9448, 1], [5943, 9448, 1], [5944, 9460, 1], [5945, 9460, 1], [5946, 9460, 1], [5947, 9460, 1], [5948, 9460, 1], [5949, 9460, 1], [5950, 9460, 1], [5951, 9460, 1], [5952, 9460, 1], [5953, 9460, 1], [5954, 9460, 1], [5955, 9460, 1], [5956, 9460, 1], [5957, 9460, 1], [5958, 9460, 1], [5959, 9460, 1], [5960, 9460, 1], [5961, 9460, 1], [5962, 9460, 1], [5963, 9460, 1], [5964, 9460, 1], [5965, 9460, 1], [5966, 9460, 1], [5967, 9460, 1], [5968, 9460, 1], [5969, 9460, 1], [5970, 9460, 1], [5971, 9460, 1], [5972, 9460, 1], [5973, 9460, 1], [5974, 9460, 1], [5975, 9460, 1], [5976, 9460, 1], [5977, 9460, 1], [5978, 9460, 1], [5979, 9460, 1], [5980, 9460, 1], [5981, 9460, 1], [5982, 9460, 1], [5983, 9460, 1], [5984, 9460, 1], [5985, 9460, 1], [5986, 9460, 1], [5987, 9460, 1], [5988, 9460, 1], [5989, 9460, 1], [5990, 9460, 1], [5991, 9460, 1], [5992, 9460, 1], [5993, 9460, 1], [5994, 9460, 1], [5995, 9460, 1], [5996, 9460, 1], [5997, 9460, 1], [5998, 9460, 1], [5999, 9460, 1], [6000, 9460, 1], [6001, 9460, 1], [6002, 9460, 1], [6003, 9460, 1], [6004, 9460, 1], [6005, 9460, 1], [6006, 9460, 1], [6007, 9460, 1], [6008, 9460, 1], [6009, 9460, 1], [6010, 9460, 1], [6011, 9460, 1], [6012, 9460, 1], [6013, 9460, 1], [6014, 9460, 1], [6015, 9460, 1], [6016, 9460, 1], [6017, 9460, 1], [6018, 9460, 1], [6019, 9460, 1], [6020, 9460, 1], [6021, 9460, 1], [6022, 9460, 1], [6023, 9460, 1], [6024, 9460, 1], [6025, 9460, 1], [6026, 9460, 1], [6027, 9460, 1], [6028, 9460, 1], [6029, 9460, 1], [6030, 9460, 1], [6031, 9460, 1], [6032, 9460, 1], [6033, 9460, 1], [6034, 9460, 1], [6035, 9460, 1], [6036, 9460, 1], [6037, 9460, 1], [6038, 9460, 1], [6039, 9460, 1], [6040, 9460, 1], [6041, 9460, 1], [6042, 9460, 1], [6043, 9460, 1], [6044, 9460, 1], [6045, 9460, 1], [6046, 9460, 1], [6047, 9460, 1], [6048, 9460, 1], [6049, 9460, 1], [6050, 9460, 1], [6051, 9460, 1], [6052, 9460, 1], [6053, 9460, 1], [6054, 9460, 1], [6055, 9460, 1], [6056, 9460, 1], [6057, 9460, 1], [6058, 9460, 1], [6059, 9460, 1], [6060, 9460, 1], [6061, 9460, 1], [6062, 9460, 1], [6063, 9460, 1], [6064, 9460, 1], [6065, 9460, 1], [6066, 9460, 1], [6067, 9460, 1], [6068, 9460, 1], [6069, 9460, 1], [6070, 9460, 1], [6071, 9460, 1], [6072, 9460, 1], [6073, 9460, 1], [6074, 9460, 1], [6075, 9460, 1], [6076, 9460, 1], [6077, 9460, 1], [6078, 9460, 1], [6079, 9460, 1], [6080, 9460, 1], [6081, 9460, 1], [6082, 9460, 1], [6083, 9460, 1], [6084, 9459, 1], [6085, 9459, 1], [6086, 9459, 1], [6087, 9459, 1], [6088, 9459, 1], [6089, 9459, 1], [6090, 9459, 1], [6091, 9459, 1], [6092, 9459, 1], [6093, 9459, 1], [6094, 9459, 1], [6095, 9459, 1], [6096, 9459, 1], [6097, 9459, 1], [6098, 9459, 1], [6099, 9459, 1], [6100, 9459, 1], [6101, 9459, 1], [6102, 9459, 1], [6103, 9459, 1], [6104, 9459, 1], [6105, 9459, 1], [6106, 9459, 1], [6107, 9459, 1], [6108, 9459, 1], [6109, 9459, 1], [6110, 9459, 1], [6111, 9459, 1], [6112, 9459, 1], [6113, 9459, 1], [6114, 9459, 1], [6115, 9459, 1], [6116, 9459, 1], [6117, 9459, 1], [6118, 9459, 1], [6119, 9459, 1], [6120, 9459, 1], [6121, 9459, 1], [6122, 9459, 1], [6123, 9459, 1], [6124, 9459, 1], [6125, 9459, 1], [6126, 9459, 1], [6127, 9459, 1], [6128, 9459, 1], [6129, 9459, 1], [6130, 9459, 1], [6131, 9459, 1], [6132, 9459, 1], [6133, 9459, 1], [6134, 9459, 1], [6135, 9459, 1], [6136, 9459, 1], [6137, 9459, 1], [6138, 9459, 1], [6139, 9459, 1], [6140, 9459, 1], [6141, 9459, 1], [6142, 9459, 1], [6143, 9459, 1], [6144, 9459, 1], [6145, 9459, 1], [6146, 9459, 1], [6147, 9459, 1], [6148, 9459, 1], [6149, 9459, 1], [6150, 9459, 1], [6151, 9459, 1], [6152, 9459, 1], [6153, 9459, 1], [6154, 9459, 1], [6155, 9459, 1], [6156, 9459, 1], [6157, 9459, 1], [6158, 9459, 1], [6159, 9459, 1], [6160, 9459, 1], [6161, 9459, 1], [6162, 9459, 1], [6163, 9459, 1], [6164, 9459, 1], [6165, 9459, 1], [6166, 9459, 1], [6167, 9459, 1], [6168, 9459, 1], [6169, 9459, 1], [6170, 9459, 1], [6171, 9459, 1], [6172, 9459, 1], [6173, 9459, 1], [6174, 9459, 1], [6175, 9459, 1], [6176, 9459, 1], [6177, 9459, 1], [6178, 9459, 1], [6179, 9459, 1], [6180, 9459, 1], [6181, 9459, 1], [6182, 9459, 1], [6183, 9459, 1], [6184, 9459, 1], [6185, 9459, 1], [6186, 9459, 1], [6187, 9459, 1], [6188, 9459, 1], [6189, 9459, 1], [6190, 9459, 1], [6191, 9459, 1], [6192, 9459, 1], [6193, 9459, 1], [6194, 9459, 1], [6195, 9459, 1], [6196, 9459, 1], [6197, 9459, 1], [6198, 9459, 1], [6199, 9459, 1], [6200, 9459, 1], [6201, 9459, 1], [6202, 9459, 1], [6203, 9459, 1], [6204, 9459, 1], [6205, 9459, 1], [6206, 9459, 1], [6207, 9459, 1], [6208, 9459, 1], [6209, 9459, 1], [6210, 9459, 1], [6211, 9459, 1], [6212, 9459, 1], [6213, 9459, 1], [6214, 9459, 1], [6215, 9459, 1], [6216, 9459, 1], [6217, 9459, 1], [6218, 9459, 1], [6219, 9459, 1], [6220, 9459, 1], [6221, 9459, 1], [6222, 9459, 1], [6223, 9459, 1], [6224, 9449, 1], [6225, 9449, 1], [6226, 9449, 1], [6227, 9449, 1], [6228, 9449, 1], [6229, 9449, 1], [6230, 9449, 1], [6231, 9449, 1], [6232, 9449, 1], [6233, 9449, 1], [6234, 9449, 1], [6235, 9449, 1], [6236, 9449, 1], [6237, 9449, 1], [6238, 9449, 1], [6239, 9449, 1], [6240, 9449, 1], [6241, 9449, 1], [6242, 9449, 1], [6243, 9449, 1], [6244, 9449, 1], [6245, 9449, 1], [6246, 9449, 1], [6247, 9449, 1], [6248, 9449, 1], [6249, 9449, 1], [6250, 9449, 1], [6251, 9449, 1], [6252, 9449, 1], [6253, 9449, 1], [6254, 9449, 1], [6255, 9449, 1], [6256, 9449, 1], [6257, 9449, 1], [6258, 9449, 1], [6259, 9449, 1], [6260, 9449, 1], [6261, 9449, 1], [6262, 9449, 1], [6263, 9449, 1], [6264, 9449, 1], [6265, 9449, 1], [6266, 9449, 1], [6267, 9449, 1], [6268, 9449, 1], [6269, 9449, 1], [6270, 9449, 1], [6271, 9449, 1], [6272, 9449, 1], [6273, 9449, 1], [6274, 9449, 1], [6275, 9449, 1], [6276, 9449, 1], [6277, 9449, 1], [6278, 9449, 1], [6279, 9449, 1], [6280, 9449, 1], [6281, 9449, 1], [6282, 9449, 1], [6283, 9449, 1], [6284, 9449, 1], [6285, 9449, 1], [6286, 9449, 1], [6287, 9449, 1], [6288, 9449, 1], [6289, 9449, 1], [6290, 9449, 1], [6291, 9449, 1], [6292, 9449, 1], [6293, 9449, 1], [6294, 9449, 1], [6295, 9449, 1], [6296, 9449, 1], [6297, 9449, 1], [6298, 9449, 1], [6299, 9449, 1], [6300, 9449, 1], [6301, 9449, 1], [6302, 9449, 1], [6303, 9449, 1], [6304, 9449, 1], [6305, 9449, 1], [6306, 9449, 1], [6307, 9449, 1], [6308, 9449, 1], [6309, 9449, 1], [6310, 9449, 1], [6311, 9449, 1], [6312, 9449, 1], [6313, 9449, 1], [6314, 9449, 1], [6315, 9449, 1], [6316, 9449, 1], [6317, 9449, 1], [6318, 9449, 1], [6319, 9449, 1], [6320, 9449, 1], [6321, 9449, 1], [6322, 9449, 1], [6323, 9449, 1], [6324, 9449, 1], [6325, 9449, 1], [6326, 9449, 1], [6327, 9449, 1], [6328, 9449, 1], [6329, 9449, 1], [6330, 9449, 1], [6331, 9449, 1], [6332, 9449, 1], [6333, 9449, 1], [6334, 9449, 1], [6335, 9449, 1], [6336, 9449, 1], [6337, 9449, 1], [6338, 9449, 1], [6339, 9449, 1], [6340, 9449, 1], [6341, 9449, 1], [6342, 9449, 1], [6343, 9449, 1], [6344, 9449, 1], [6345, 9449, 1], [6346, 9449, 1], [6347, 9449, 1], [6348, 9449, 1], [6349, 9449, 1], [6350, 9449, 1], [6351, 9449, 1], [6352, 9449, 1], [6353, 9449, 1], [6354, 9449, 1], [6355, 9449, 1], [6356, 9449, 1], [6357, 9449, 1], [6358, 9449, 1], [6359, 9449, 1], [6360, 9449, 1], [6361, 9449, 1], [6362, 9449, 1], [6363, 9449, 1], [6364, 9473, 1], [6365, 9473, 1], [6366, 9473, 1], [6367, 9473, 1], [6368, 9473, 1], [6369, 9473, 1], [6370, 9473, 1], [6371, 9473, 1], [6372, 9473, 1], [6373, 9473, 1], [6374, 9473, 1], [6375, 9473, 1], [6376, 9473, 1], [6377, 9473, 1], [6378, 9473, 1], [6379, 9473, 1], [6380, 9473, 1], [6381, 9473, 1], [6382, 9473, 1], [6383, 9473, 1], [6384, 9473, 1], [6385, 9473, 1], [6386, 9473, 1], [6387, 9473, 1], [6388, 9473, 1], [6389, 9473, 1], [6390, 9473, 1], [6391, 9473, 1], [6392, 9473, 1], [6393, 9473, 1], [6394, 9473, 1], [6395, 9473, 1], [6396, 9473, 1], [6397, 9473, 1], [6398, 9473, 1], [6399, 9473, 1], [6400, 9473, 1], [6401, 9473, 1], [6402, 9473, 1], [6403, 9473, 1], [6404, 9473, 1], [6405, 9473, 1], [6406, 9473, 1], [6407, 9473, 1], [6408, 9473, 1], [6409, 9473, 1], [6410, 9473, 1], [6411, 9473, 1], [6412, 9473, 1], [6413, 9473, 1], [6414, 9473, 1], [6415, 9473, 1], [6416, 9473, 1], [6417, 9473, 1], [6418, 9473, 1], [6419, 9473, 1], [6420, 9473, 1], [6421, 9473, 1], [6422, 9473, 1], [6423, 9473, 1], [6424, 9473, 1], [6425, 9473, 1], [6426, 9473, 1], [6427, 9473, 1], [6428, 9473, 1], [6429, 9473, 1], [6430, 9473, 1], [6431, 9473, 1], [6432, 9473, 1], [6433, 9473, 1], [6434, 9473, 1], [6435, 9473, 1], [6436, 9473, 1], [6437, 9473, 1], [6438, 9473, 1], [6439, 9473, 1], [6440, 9473, 1], [6441, 9473, 1], [6442, 9473, 1], [6443, 9473, 1], [6444, 9473, 1], [6445, 9473, 1], [6446, 9473, 1], [6447, 9473, 1], [6448, 9473, 1], [6449, 9473, 1], [6450, 9473, 1], [6451, 9473, 1], [6452, 9473, 1], [6453, 9473, 1], [6454, 9473, 1], [6455, 9473, 1], [6456, 9473, 1], [6457, 9473, 1], [6458, 9473, 1], [6459, 9473, 1], [6460, 9473, 1], [6461, 9473, 1], [6462, 9473, 1], [6463, 9473, 1], [6464, 9473, 1], [6465, 9473, 1], [6466, 9473, 1], [6467, 9473, 1], [6468, 9473, 1], [6469, 9473, 1], [6470, 9473, 1], [6471, 9473, 1], [6472, 9473, 1], [6473, 9473, 1], [6474, 9473, 1], [6475, 9473, 1], [6476, 9473, 1], [6477, 9473, 1], [6478, 9473, 1], [6479, 9473, 1], [6480, 9473, 1], [6481, 9473, 1], [6482, 9473, 1], [6483, 9473, 1], [6484, 9473, 1], [6485, 9473, 1], [6486, 9473, 1], [6487, 9473, 1], [6488, 9473, 1], [6489, 9473, 1], [6490, 9473, 1], [6491, 9473, 1], [6492, 9473, 1], [6493, 9473, 1], [6494, 9473, 1], [6495, 9473, 1], [6496, 9473, 1], [6497, 9473, 1], [6498, 9473, 1], [6499, 9473, 1], [6500, 9473, 1], [6501, 9473, 1], [6502, 9473, 1], [6503, 9473, 1], [6504, 9473, 1], [6505, 9473, 1], [6506, 9473, 1], [6507, 9473, 1], [6508, 9473, 1], [6509, 9473, 1], [6510, 9473, 1], [6511, 9473, 1], [6512, 9473, 1], [6513, 9473, 1], [6514, 9473, 1], [6515, 9473, 1], [6516, 9473, 1], [6517, 9473, 1], [6518, 9473, 1], [6519, 9473, 1], [6520, 9473, 1], [6521, 9473, 1], [6522, 9473, 1], [6523, 9473, 1], [6524, 9473, 1], [6525, 9473, 1], [6526, 9473, 1], [6527, 9473, 1], [6528, 9473, 1], [6529, 9473, 1], [6530, 9473, 1], [6531, 9473, 1], [6532, 9473, 1], [6533, 9473, 1], [6534, 9473, 1], [6535, 9473, 1], [6536, 9473, 1], [6537, 9473, 1], [6538, 9473, 1], [6539, 9473, 1], [6540, 9473, 1], [6541, 9473, 1], [6542, 9473, 1], [6543, 9473, 1], [6544, 9473, 1], [6545, 9473, 1], [6546, 9473, 1], [6547, 9473, 1], [6548, 9473, 1], [6549, 9473, 1], [6550, 9473, 1], [6551, 9473, 1], [6552, 9473, 1], [6553, 9473, 1], [6554, 9473, 1], [6555, 9473, 1], [6556, 9473, 1], [6557, 9473, 1], [6558, 9473, 1], [6559, 9473, 1], [6560, 9473, 1], [6561, 9473, 1], [6562, 9473, 1], [6563, 9473, 1], [6564, 9473, 1], [6565, 9473, 1], [6566, 9473, 1], [6567, 9473, 1], [6568, 9473, 1], [6569, 9473, 1], [6570, 9473, 1], [6571, 9473, 1], [6572, 9473, 1], [6573, 9473, 1], [6574, 9473, 1], [6575, 9473, 1], [6576, 9473, 1], [6577, 9473, 1], [6578, 9473, 1], [6579, 9473, 1], [6580, 9473, 1], [6581, 9473, 1], [6582, 9473, 1], [6583, 9473, 1], [6584, 9473, 1], [6585, 9473, 1], [6586, 9473, 1], [6587, 9473, 1], [6588, 9473, 1], [6589, 9473, 1], [6590, 9473, 1], [6591, 9473, 1], [6592, 9473, 1], [6593, 9473, 1], [6594, 9473, 1], [6595, 9473, 1], [6596, 9473, 1], [6597, 9473, 1], [6598, 9473, 1], [6599, 9473, 1], [6600, 9473, 1], [6601, 9473, 1], [6602, 9473, 1], [6603, 9473, 1], [6604, 9473, 1], [6605, 9473, 1], [6606, 9473, 1], [6607, 9473, 1], [6608, 9473, 1], [6609, 9473, 1], [6610, 9473, 1], [6611, 9473, 1], [6612, 9473, 1], [6613, 9473, 1], [6614, 9473, 1], [6615, 9473, 1], [6616, 9473, 1], [6617, 9473, 1], [6618, 9473, 1], [6619, 9473, 1], [6620, 9473, 1], [6621, 9473, 1], [6622, 9473, 1], [6623, 9473, 1], [6624, 9473, 1], [6625, 9473, 1], [6626, 9473, 1], [6627, 9473, 1], [6628, 9473, 1], [6629, 9473, 1], [6630, 9473, 1], [6631, 9473, 1], [6632, 9473, 1], [6633, 9473, 1], [6634, 9473, 1], [6635, 9473, 1], [6636, 9473, 1], [6637, 9473, 1], [6638, 9473, 1], [6639, 9473, 1], [6640, 9473, 1], [6641, 9473, 1], [6642, 9473, 1], [6643, 9473, 1], [6644, 9449, 1], [6645, 9449, 1], [6646, 9449, 1], [6647, 9449, 1], [6648, 9449, 1], [6649, 9449, 1], [6650, 9449, 1], [6651, 9449, 1], [6652, 9449, 1], [6653, 9449, 1], [6654, 9449, 1], [6655, 9449, 1], [6656, 9449, 1], [6657, 9449, 1], [6658, 9449, 1], [6659, 9449, 1], [6660, 9449, 1], [6661, 9449, 1], [6662, 9449, 1], [6663, 9449, 1], [6664, 9449, 1], [6665, 9449, 1], [6666, 9449, 1], [6667, 9449, 1], [6668, 9449, 1], [6669, 9449, 1], [6670, 9449, 1], [6671, 9449, 1], [6672, 9449, 1], [6673, 9449, 1], [6674, 9449, 1], [6675, 9449, 1], [6676, 9449, 1], [6677, 9449, 1], [6678, 9449, 1], [6679, 9449, 1], [6680, 9449, 1], [6681, 9449, 1], [6682, 9449, 1], [6683, 9449, 1], [6684, 9449, 1], [6685, 9449, 1], [6686, 9449, 1], [6687, 9449, 1], [6688, 9449, 1], [6689, 9449, 1], [6690, 9449, 1], [6691, 9449, 1], [6692, 9449, 1], [6693, 9449, 1], [6694, 9449, 1], [6695, 9449, 1], [6696, 9449, 1], [6697, 9449, 1], [6698, 9449, 1], [6699, 9449, 1], [6700, 9449, 1], [6701, 9449, 1], [6702, 9449, 1], [6703, 9449, 1], [6704, 9449, 1], [6705, 9449, 1], [6706, 9449, 1], [6707, 9449, 1], [6708, 9449, 1], [6709, 9449, 1], [6710, 9449, 1], [6711, 9449, 1], [6712, 9449, 1], [6713, 9449, 1], [6714, 9449, 1], [6715, 9449, 1], [6716, 9449, 1], [6717, 9449, 1], [6718, 9449, 1], [6719, 9449, 1], [6720, 9449, 1], [6721, 9449, 1], [6722, 9449, 1], [6723, 9449, 1], [6724, 9449, 1], [6725, 9449, 1], [6726, 9449, 1], [6727, 9449, 1], [6728, 9449, 1], [6729, 9449, 1], [6730, 9449, 1], [6731, 9449, 1], [6732, 9449, 1], [6733, 9449, 1], [6734, 9449, 1], [6735, 9449, 1], [6736, 9449, 1], [6737, 9449, 1], [6738, 9449, 1], [6739, 9449, 1], [6740, 9449, 1], [6741, 9449, 1], [6742, 9449, 1], [6743, 9449, 1], [6744, 9449, 1], [6745, 9449, 1], [6746, 9449, 1], [6747, 9449, 1], [6748, 9449, 1], [6749, 9449, 1], [6750, 9449, 1], [6751, 9449, 1], [6752, 9449, 1], [6753, 9449, 1], [6754, 9449, 1], [6755, 9449, 1], [6756, 9449, 1], [6757, 9449, 1], [6758, 9449, 1], [6759, 9449, 1], [6760, 9449, 1], [6761, 9449, 1], [6762, 9449, 1], [6763, 9449, 1], [6764, 9449, 1], [6765, 9449, 1], [6766, 9449, 1], [6767, 9449, 1], [6768, 9449, 1], [6769, 9449, 1], [6770, 9449, 1], [6771, 9449, 1], [6772, 9449, 1], [6773, 9449, 1], [6774, 9449, 1], [6775, 9449, 1], [6776, 9449, 1], [6777, 9449, 1], [6778, 9449, 1], [6779, 9449, 1], [6780, 9449, 1], [6781, 9449, 1], [6782, 9449, 1], [6783, 9449, 1], [6784, 9459, 1], [6785, 9459, 1], [6786, 9459, 1], [6787, 9459, 1], [6788, 9459, 1], [6789, 9459, 1], [6790, 9459, 1], [6791, 9459, 1], [6792, 9459, 1], [6793, 9459, 1], [6794, 9459, 1], [6795, 9459, 1], [6796, 9459, 1], [6797, 9459, 1], [6798, 9459, 1], [6799, 9459, 1], [6800, 9459, 1], [6801, 9459, 1], [6802, 9459, 1], [6803, 9459, 1], [6804, 9459, 1], [6805, 9459, 1], [6806, 9459, 1], [6807, 9459, 1], [6808, 9459, 1], [6809, 9459, 1], [6810, 9459, 1], [6811, 9459, 1], [6812, 9459, 1], [6813, 9459, 1], [6814, 9459, 1], [6815, 9459, 1], [6816, 9459, 1], [6817, 9459, 1], [6818, 9459, 1], [6819, 9459, 1], [6820, 9459, 1], [6821, 9459, 1], [6822, 9459, 1], [6823, 9459, 1], [6824, 9459, 1], [6825, 9459, 1], [6826, 9459, 1], [6827, 9459, 1], [6828, 9459, 1], [6829, 9459, 1], [6830, 9459, 1], [6831, 9459, 1], [6832, 9459, 1], [6833, 9459, 1], [6834, 9459, 1], [6835, 9459, 1], [6836, 9459, 1], [6837, 9459, 1], [6838, 9459, 1], [6839, 9459, 1], [6840, 9459, 1], [6841, 9459, 1], [6842, 9459, 1], [6843, 9459, 1], [6844, 9459, 1], [6845, 9459, 1], [6846, 9459, 1], [6847, 9459, 1], [6848, 9459, 1], [6849, 9459, 1], [6850, 9459, 1], [6851, 9459, 1], [6852, 9459, 1], [6853, 9459, 1], [6854, 9459, 1], [6855, 9459, 1], [6856, 9459, 1], [6857, 9459, 1], [6858, 9459, 1], [6859, 9459, 1], [6860, 9459, 1], [6861, 9459, 1], [6862, 9459, 1], [6863, 9459, 1], [6864, 9459, 1], [6865, 9459, 1], [6866, 9459, 1], [6867, 9459, 1], [6868, 9459, 1], [6869, 9459, 1], [6870, 9459, 1], [6871, 9459, 1], [6872, 9459, 1], [6873, 9459, 1], [6874, 9459, 1], [6875, 9459, 1], [6876, 9459, 1], [6877, 9459, 1], [6878, 9459, 1], [6879, 9459, 1], [6880, 9459, 1], [6881, 9459, 1], [6882, 9459, 1], [6883, 9459, 1], [6884, 9459, 1], [6885, 9459, 1], [6886, 9459, 1], [6887, 9459, 1], [6888, 9459, 1], [6889, 9459, 1], [6890, 9459, 1], [6891, 9459, 1], [6892, 9459, 1], [6893, 9459, 1], [6894, 9459, 1], [6895, 9459, 1], [6896, 9459, 1], [6897, 9459, 1], [6898, 9459, 1], [6899, 9459, 1], [6900, 9459, 1], [6901, 9459, 1], [6902, 9459, 1], [6903, 9459, 1], [6904, 9459, 1], [6905, 9459, 1], [6906, 9459, 1], [6907, 9459, 1], [6908, 9459, 1], [6909, 9459, 1], [6910, 9459, 1], [6911, 9459, 1], [6912, 9459, 1], [6913, 9459, 1], [6914, 9459, 1], [6915, 9459, 1], [6916, 9459, 1], [6917, 9459, 1], [6918, 9459, 1], [6919, 9459, 1], [6920, 9459, 1], [6921, 9459, 1], [6922, 9459, 1], [6923, 9459, 1], [6924, 9462, 1], [6925, 9462, 1], [6926, 9462, 1], [6927, 9462, 1], [6928, 9462, 1], [6929, 9462, 1], [6930, 9462, 1], [6931, 9462, 1], [6932, 9462, 1], [6933, 9462, 1], [6934, 9462, 1], [6935, 9462, 1], [6936, 9462, 1], [6937, 9462, 1], [6938, 9462, 1], [6939, 9462, 1], [6940, 9462, 1], [6941, 9462, 1], [6942, 9462, 1], [6943, 9462, 1], [6944, 9462, 1], [6945, 9462, 1], [6946, 9462, 1], [6947, 9462, 1], [6948, 9462, 1], [6949, 9462, 1], [6950, 9462, 1], [6951, 9462, 1], [6952, 9462, 1], [6953, 9462, 1], [6954, 9462, 1], [6955, 9462, 1], [6956, 9462, 1], [6957, 9462, 1], [6958, 9462, 1], [6959, 9462, 1], [6960, 9462, 1], [6961, 9462, 1], [6962, 9462, 1], [6963, 9462, 1], [6964, 9462, 1], [6965, 9462, 1], [6966, 9462, 1], [6967, 9462, 1], [6968, 9462, 1], [6969, 9462, 1], [6970, 9462, 1], [6971, 9462, 1], [6972, 9462, 1], [6973, 9462, 1], [6974, 9462, 1], [6975, 9462, 1], [6976, 9462, 1], [6977, 9462, 1], [6978, 9462, 1], [6979, 9462, 1], [6980, 9462, 1], [6981, 9462, 1], [6982, 9462, 1], [6983, 9462, 1], [6984, 9462, 1], [6985, 9462, 1], [6986, 9462, 1], [6987, 9462, 1], [6988, 9462, 1], [6989, 9462, 1], [6990, 9462, 1], [6991, 9462, 1], [6992, 9462, 1], [6993, 9462, 1], [6994, 9462, 1], [6995, 9462, 1], [6996, 9462, 1], [6997, 9462, 1], [6998, 9462, 1], [6999, 9462, 1], [7000, 9462, 1], [7001, 9462, 1], [7002, 9462, 1], [7003, 9462, 1], [7004, 9462, 1], [7005, 9462, 1], [7006, 9462, 1], [7007, 9462, 1], [7008, 9462, 1], [7009, 9462, 1], [7010, 9462, 1], [7011, 9462, 1], [7012, 9462, 1], [7013, 9462, 1], [7014, 9462, 1], [7015, 9462, 1], [7016, 9462, 1], [7017, 9462, 1], [7018, 9462, 1], [7019, 9462, 1], [7020, 9462, 1], [7021, 9462, 1], [7022, 9462, 1], [7023, 9462, 1], [7024, 9462, 1], [7025, 9462, 1], [7026, 9462, 1], [7027, 9462, 1], [7028, 9462, 1], [7029, 9462, 1], [7030, 9462, 1], [7031, 9462, 1], [7032, 9462, 1], [7033, 9462, 1], [7034, 9462, 1], [7035, 9462, 1], [7036, 9462, 1], [7037, 9462, 1], [7038, 9462, 1], [7039, 9462, 1], [7040, 9462, 1], [7041, 9462, 1], [7042, 9462, 1], [7043, 9462, 1], [7044, 9462, 1], [7045, 9462, 1], [7046, 9462, 1], [7047, 9462, 1], [7048, 9462, 1], [7049, 9462, 1], [7050, 9462, 1], [7051, 9462, 1], [7052, 9462, 1], [7053, 9462, 1], [7054, 9462, 1], [7055, 9462, 1], [7056, 9462, 1], [7057, 9462, 1], [7058, 9462, 1], [7059, 9462, 1], [7060, 9462, 1], [7061, 9462, 1], [7062, 9462, 1], [7063, 9462, 1], [7064, 9453, 1], [7065, 9453, 1], [7066, 9453, 1], [7067, 9453, 1], [7068, 9453, 1], [7069, 9453, 1], [7070, 9453, 1], [7071, 9453, 1], [7072, 9453, 1], [7073, 9453, 1], [7074, 9453, 1], [7075, 9453, 1], [7076, 9453, 1], [7077, 9453, 1], [7078, 9453, 1], [7079, 9453, 1], [7080, 9453, 1], [7081, 9453, 1], [7082, 9453, 1], [7083, 9453, 1], [7084, 9453, 1], [7085, 9453, 1], [7086, 9453, 1], [7087, 9453, 1], [7088, 9453, 1], [7089, 9453, 1], [7090, 9453, 1], [7091, 9453, 1], [7092, 9453, 1], [7093, 9453, 1], [7094, 9453, 1], [7095, 9453, 1], [7096, 9453, 1], [7097, 9453, 1], [7098, 9453, 1], [7099, 9453, 1], [7100, 9453, 1], [7101, 9453, 1], [7102, 9453, 1], [7103, 9453, 1], [7104, 9453, 1], [7105, 9453, 1], [7106, 9453, 1], [7107, 9453, 1], [7108, 9453, 1], [7109, 9453, 1], [7110, 9453, 1], [7111, 9453, 1], [7112, 9453, 1], [7113, 9453, 1], [7114, 9453, 1], [7115, 9453, 1], [7116, 9453, 1], [7117, 9453, 1], [7118, 9453, 1], [7119, 9453, 1], [7120, 9453, 1], [7121, 9453, 1], [7122, 9453, 1], [7123, 9453, 1], [7124, 9453, 1], [7125, 9453, 1], [7126, 9453, 1], [7127, 9453, 1], [7128, 9453, 1], [7129, 9453, 1], [7130, 9453, 1], [7131, 9453, 1], [7132, 9453, 1], [7133, 9453, 1], [7134, 9453, 1], [7135, 9453, 1], [7136, 9453, 1], [7137, 9453, 1], [7138, 9453, 1], [7139, 9453, 1], [7140, 9453, 1], [7141, 9453, 1], [7142, 9453, 1], [7143, 9453, 1], [7144, 9453, 1], [7145, 9453, 1], [7146, 9453, 1], [7147, 9453, 1], [7148, 9453, 1], [7149, 9453, 1], [7150, 9453, 1], [7151, 9453, 1], [7152, 9453, 1], [7153, 9453, 1], [7154, 9453, 1], [7155, 9453, 1], [7156, 9453, 1], [7157, 9453, 1], [7158, 9453, 1], [7159, 9453, 1], [7160, 9453, 1], [7161, 9453, 1], [7162, 9453, 1], [7163, 9453, 1], [7164, 9453, 1], [7165, 9453, 1], [7166, 9453, 1], [7167, 9453, 1], [7168, 9453, 1], [7169, 9453, 1], [7170, 9453, 1], [7171, 9453, 1], [7172, 9453, 1], [7173, 9453, 1], [7174, 9453, 1], [7175, 9453, 1], [7176, 9453, 1], [7177, 9453, 1], [7178, 9453, 1], [7179, 9453, 1], [7180, 9453, 1], [7181, 9453, 1], [7182, 9453, 1], [7183, 9453, 1], [7184, 9453, 1], [7185, 9453, 1], [7186, 9453, 1], [7187, 9453, 1], [7188, 9453, 1], [7189, 9453, 1], [7190, 9453, 1], [7191, 9453, 1], [7192, 9453, 1], [7193, 9453, 1], [7194, 9453, 1], [7195, 9453, 1], [7196, 9453, 1], [7197, 9453, 1], [7198, 9453, 1], [7199, 9453, 1], [7200, 9453, 1], [7201, 9453, 1], [7202, 9453, 1], [7203, 9453, 1], [7204, 9467, 1], [7205, 9467, 1], [7206, 9467, 1], [7207, 9467, 1], [7208, 9467, 1], [7209, 9467, 1], [7210, 9467, 1], [7211, 9467, 1], [7212, 9467, 1], [7213, 9467, 1], [7214, 9467, 1], [7215, 9467, 1], [7216, 9467, 1], [7217, 9467, 1], [7218, 9467, 1], [7219, 9467, 1], [7220, 9467, 1], [7221, 9467, 1], [7222, 9467, 1], [7223, 9467, 1], [7224, 9467, 1], [7225, 9467, 1], [7226, 9467, 1], [7227, 9467, 1], [7228, 9467, 1], [7229, 9467, 1], [7230, 9467, 1], [7231, 9467, 1], [7232, 9467, 1], [7233, 9467, 1], [7234, 9467, 1], [7235, 9467, 1], [7236, 9467, 1], [7237, 9467, 1], [7238, 9467, 1], [7239, 9467, 1], [7240, 9467, 1], [7241, 9467, 1], [7242, 9467, 1], [7243, 9467, 1], [7244, 9467, 1], [7245, 9467, 1], [7246, 9467, 1], [7247, 9467, 1], [7248, 9467, 1], [7249, 9467, 1], [7250, 9467, 1], [7251, 9467, 1], [7252, 9467, 1], [7253, 9467, 1], [7254, 9467, 1], [7255, 9467, 1], [7256, 9467, 1], [7257, 9467, 1], [7258, 9467, 1], [7259, 9467, 1], [7260, 9467, 1], [7261, 9467, 1], [7262, 9467, 1], [7263, 9467, 1], [7264, 9467, 1], [7265, 9467, 1], [7266, 9467, 1], [7267, 9467, 1], [7268, 9467, 1], [7269, 9467, 1], [7270, 9467, 1], [7271, 9467, 1], [7272, 9467, 1], [7273, 9467, 1], [7274, 9467, 1], [7275, 9467, 1], [7276, 9467, 1], [7277, 9467, 1], [7278, 9467, 1], [7279, 9467, 1], [7280, 9467, 1], [7281, 9467, 1], [7282, 9467, 1], [7283, 9467, 1], [7284, 9467, 1], [7285, 9467, 1], [7286, 9467, 1], [7287, 9467, 1], [7288, 9467, 1], [7289, 9467, 1], [7290, 9467, 1], [7291, 9467, 1], [7292, 9467, 1], [7293, 9467, 1], [7294, 9467, 1], [7295, 9467, 1], [7296, 9467, 1], [7297, 9467, 1], [7298, 9467, 1], [7299, 9467, 1], [7300, 9467, 1], [7301, 9467, 1], [7302, 9467, 1], [7303, 9467, 1], [7304, 9467, 1], [7305, 9467, 1], [7306, 9467, 1], [7307, 9467, 1], [7308, 9467, 1], [7309, 9467, 1], [7310, 9467, 1], [7311, 9467, 1], [7312, 9467, 1], [7313, 9467, 1], [7314, 9467, 1], [7315, 9467, 1], [7316, 9467, 1], [7317, 9467, 1], [7318, 9467, 1], [7319, 9467, 1], [7320, 9467, 1], [7321, 9467, 1], [7322, 9467, 1], [7323, 9467, 1], [7324, 9467, 1], [7325, 9467, 1], [7326, 9467, 1], [7327, 9467, 1], [7328, 9467, 1], [7329, 9467, 1], [7330, 9467, 1], [7331, 9467, 1], [7332, 9467, 1], [7333, 9467, 1], [7334, 9467, 1], [7335, 9467, 1], [7336, 9467, 1], [7337, 9467, 1], [7338, 9467, 1], [7339, 9467, 1], [7340, 9467, 1], [7341, 9467, 1], [7342, 9467, 1], [7343, 9467, 1], [7344, 9467, 1], [7345, 9467, 1], [7346, 9467, 1], [7347, 9467, 1], [7348, 9467, 1], [7349, 9467, 1], [7350, 9467, 1], [7351, 9467, 1], [7352, 9467, 1], [7353, 9467, 1], [7354, 9467, 1], [7355, 9467, 1], [7356, 9467, 1], [7357, 9467, 1], [7358, 9467, 1], [7359, 9467, 1], [7360, 9467, 1], [7361, 9467, 1], [7362, 9467, 1], [7363, 9467, 1], [7364, 9467, 1], [7365, 9467, 1], [7366, 9467, 1], [7367, 9467, 1], [7368, 9467, 1], [7369, 9467, 1], [7370, 9467, 1], [7371, 9467, 1], [7372, 9467, 1], [7373, 9467, 1], [7374, 9467, 1], [7375, 9467, 1], [7376, 9467, 1], [7377, 9467, 1], [7378, 9467, 1], [7379, 9467, 1], [7380, 9467, 1], [7381, 9467, 1], [7382, 9467, 1], [7383, 9467, 1], [7384, 9467, 1], [7385, 9467, 1], [7386, 9467, 1], [7387, 9467, 1], [7388, 9467, 1], [7389, 9467, 1], [7390, 9467, 1], [7391, 9467, 1], [7392, 9467, 1], [7393, 9467, 1], [7394, 9467, 1], [7395, 9467, 1], [7396, 9467, 1], [7397, 9467, 1], [7398, 9467, 1], [7399, 9467, 1], [7400, 9467, 1], [7401, 9467, 1], [7402, 9467, 1], [7403, 9467, 1], [7404, 9467, 1], [7405, 9467, 1], [7406, 9467, 1], [7407, 9467, 1], [7408, 9467, 1], [7409, 9467, 1], [7410, 9467, 1], [7411, 9467, 1], [7412, 9467, 1], [7413, 9467, 1], [7414, 9467, 1], [7415, 9467, 1], [7416, 9467, 1], [7417, 9467, 1], [7418, 9467, 1], [7419, 9467, 1], [7420, 9467, 1], [7421, 9467, 1], [7422, 9467, 1], [7423, 9467, 1], [7424, 9467, 1], [7425, 9467, 1], [7426, 9467, 1], [7427, 9467, 1], [7428, 9467, 1], [7429, 9467, 1], [7430, 9467, 1], [7431, 9467, 1], [7432, 9467, 1], [7433, 9467, 1], [7434, 9467, 1], [7435, 9467, 1], [7436, 9467, 1], [7437, 9467, 1], [7438, 9467, 1], [7439, 9467, 1], [7440, 9467, 1], [7441, 9467, 1], [7442, 9467, 1], [7443, 9467, 1], [7444, 9467, 1], [7445, 9467, 1], [7446, 9467, 1], [7447, 9467, 1], [7448, 9467, 1], [7449, 9467, 1], [7450, 9467, 1], [7451, 9467, 1], [7452, 9467, 1], [7453, 9467, 1], [7454, 9467, 1], [7455, 9467, 1], [7456, 9467, 1], [7457, 9467, 1], [7458, 9467, 1], [7459, 9467, 1], [7460, 9467, 1], [7461, 9467, 1], [7462, 9467, 1], [7463, 9467, 1], [7464, 9467, 1], [7465, 9467, 1], [7466, 9467, 1], [7467, 9467, 1], [7468, 9467, 1], [7469, 9467, 1], [7470, 9467, 1], [7471, 9467, 1], [7472, 9467, 1], [7473, 9467, 1], [7474, 9467, 1], [7475, 9467, 1], [7476, 9467, 1], [7477, 9467, 1], [7478, 9467, 1], [7479, 9467, 1], [7480, 9467, 1], [7481, 9467, 1], [7482, 9467, 1], [7483, 9467, 1], [7484, 9453, 1], [7485, 9453, 1], [7486, 9453, 1], [7487, 9453, 1], [7488, 9453, 1], [7489, 9453, 1], [7490, 9453, 1], [7491, 9453, 1], [7492, 9453, 1], [7493, 9453, 1], [7494, 9453, 1], [7495, 9453, 1], [7496, 9453, 1], [7497, 9453, 1], [7498, 9453, 1], [7499, 9453, 1], [7500, 9453, 1], [7501, 9453, 1], [7502, 9453, 1], [7503, 9453, 1], [7504, 9453, 1], [7505, 9453, 1], [7506, 9453, 1], [7507, 9453, 1], [7508, 9453, 1], [7509, 9453, 1], [7510, 9453, 1], [7511, 9453, 1], [7512, 9453, 1], [7513, 9453, 1], [7514, 9453, 1], [7515, 9453, 1], [7516, 9453, 1], [7517, 9453, 1], [7518, 9453, 1], [7519, 9453, 1], [7520, 9453, 1], [7521, 9453, 1], [7522, 9453, 1], [7523, 9453, 1], [7524, 9453, 1], [7525, 9453, 1], [7526, 9453, 1], [7527, 9453, 1], [7528, 9453, 1], [7529, 9453, 1], [7530, 9453, 1], [7531, 9453, 1], [7532, 9453, 1], [7533, 9453, 1], [7534, 9453, 1], [7535, 9453, 1], [7536, 9453, 1], [7537, 9453, 1], [7538, 9453, 1], [7539, 9453, 1], [7540, 9453, 1], [7541, 9453, 1], [7542, 9453, 1], [7543, 9453, 1], [7544, 9453, 1], [7545, 9453, 1], [7546, 9453, 1], [7547, 9453, 1], [7548, 9453, 1], [7549, 9453, 1], [7550, 9453, 1], [7551, 9453, 1], [7552, 9453, 1], [7553, 9453, 1], [7554, 9453, 1], [7555, 9453, 1], [7556, 9453, 1], [7557, 9453, 1], [7558, 9453, 1], [7559, 9453, 1], [7560, 9453, 1], [7561, 9453, 1], [7562, 9453, 1], [7563, 9453, 1], [7564, 9453, 1], [7565, 9453, 1], [7566, 9453, 1], [7567, 9453, 1], [7568, 9453, 1], [7569, 9453, 1], [7570, 9453, 1], [7571, 9453, 1], [7572, 9453, 1], [7573, 9453, 1], [7574, 9453, 1], [7575, 9453, 1], [7576, 9453, 1], [7577, 9453, 1], [7578, 9453, 1], [7579, 9453, 1], [7580, 9453, 1], [7581, 9453, 1], [7582, 9453, 1], [7583, 9453, 1], [7584, 9453, 1], [7585, 9453, 1], [7586, 9453, 1], [7587, 9453, 1], [7588, 9453, 1], [7589, 9453, 1], [7590, 9453, 1], [7591, 9453, 1], [7592, 9453, 1], [7593, 9453, 1], [7594, 9453, 1], [7595, 9453, 1], [7596, 9453, 1], [7597, 9453, 1], [7598, 9453, 1], [7599, 9453, 1], [7600, 9453, 1], [7601, 9453, 1], [7602, 9453, 1], [7603, 9453, 1], [7604, 9453, 1], [7605, 9453, 1], [7606, 9453, 1], [7607, 9453, 1], [7608, 9453, 1], [7609, 9453, 1], [7610, 9453, 1], [7611, 9453, 1], [7612, 9453, 1], [7613, 9453, 1], [7614, 9453, 1], [7615, 9453, 1], [7616, 9453, 1], [7617, 9453, 1], [7618, 9453, 1], [7619, 9453, 1], [7620, 9453, 1], [7621, 9453, 1], [7622, 9453, 1], [7623, 9453, 1], [7624, 9462, 1], [7625, 9462, 1], [7626, 9462, 1], [7627, 9462, 1], [7628, 9462, 1], [7629, 9462, 1], [7630, 9462, 1], [7631, 9462, 1], [7632, 9462, 1], [7633, 9462, 1], [7634, 9462, 1], [7635, 9462, 1], [7636, 9462, 1], [7637, 9462, 1], [7638, 9462, 1], [7639, 9462, 1], [7640, 9462, 1], [7641, 9462, 1], [7642, 9462, 1], [7643, 9462, 1], [7644, 9462, 1], [7645, 9462, 1], [7646, 9462, 1], [7647, 9462, 1], [7648, 9462, 1], [7649, 9462, 1], [7650, 9462, 1], [7651, 9462, 1], [7652, 9462, 1], [7653, 9462, 1], [7654, 9462, 1], [7655, 9462, 1], [7656, 9462, 1], [7657, 9462, 1], [7658, 9462, 1], [7659, 9462, 1], [7660, 9462, 1], [7661, 9462, 1], [7662, 9462, 1], [7663, 9462, 1], [7664, 9462, 1], [7665, 9462, 1], [7666, 9462, 1], [7667, 9462, 1], [7668, 9462, 1], [7669, 9462, 1], [7670, 9462, 1], [7671, 9462, 1], [7672, 9462, 1], [7673, 9462, 1], [7674, 9462, 1], [7675, 9462, 1], [7676, 9462, 1], [7677, 9462, 1], [7678, 9462, 1], [7679, 9462, 1], [7680, 9462, 1], [7681, 9462, 1], [7682, 9462, 1], [7683, 9462, 1], [7684, 9462, 1], [7685, 9462, 1], [7686, 9462, 1], [7687, 9462, 1], [7688, 9462, 1], [7689, 9462, 1], [7690, 9462, 1], [7691, 9462, 1], [7692, 9462, 1], [7693, 9462, 1], [7694, 9462, 1], [7695, 9462, 1], [7696, 9462, 1], [7697, 9462, 1], [7698, 9462, 1], [7699, 9462, 1], [7700, 9462, 1], [7701, 9462, 1], [7702, 9462, 1], [7703, 9462, 1], [7704, 9462, 1], [7705, 9462, 1], [7706, 9462, 1], [7707, 9462, 1], [7708, 9462, 1], [7709, 9462, 1], [7710, 9462, 1], [7711, 9462, 1], [7712, 9462, 1], [7713, 9462, 1], [7714, 9462, 1], [7715, 9462, 1], [7716, 9462, 1], [7717, 9462, 1], [7718, 9462, 1], [7719, 9462, 1], [7720, 9462, 1], [7721, 9462, 1], [7722, 9462, 1], [7723, 9462, 1], [7724, 9462, 1], [7725, 9462, 1], [7726, 9462, 1], [7727, 9462, 1], [7728, 9462, 1], [7729, 9462, 1], [7730, 9462, 1], [7731, 9462, 1], [7732, 9462, 1], [7733, 9462, 1], [7734, 9462, 1], [7735, 9462, 1], [7736, 9462, 1], [7737, 9462, 1], [7738, 9462, 1], [7739, 9462, 1], [7740, 9462, 1], [7741, 9462, 1], [7742, 9462, 1], [7743, 9462, 1], [7744, 9462, 1], [7745, 9462, 1], [7746, 9462, 1], [7747, 9462, 1], [7748, 9462, 1], [7749, 9462, 1], [7750, 9462, 1], [7751, 9462, 1], [7752, 9462, 1], [7753, 9462, 1], [7754, 9462, 1], [7755, 9462, 1], [7756, 9462, 1], [7757, 9462, 1], [7758, 9462, 1], [7759, 9462, 1], [7760, 9462, 1], [7761, 9462, 1], [7762, 9462, 1], [7763, 9462, 1], [7764, 9457, 1], [7765, 9457, 1], [7766, 9457, 1], [7767, 9457, 1], [7768, 9457, 1], [7769, 9457, 1], [7770, 9457, 1], [7771, 9457, 1], [7772, 9457, 1], [7773, 9457, 1], [7774, 9457, 1], [7775, 9457, 1], [7776, 9457, 1], [7777, 9457, 1], [7778, 9457, 1], [7779, 9457, 1], [7780, 9457, 1], [7781, 9457, 1], [7782, 9457, 1], [7783, 9457, 1], [7784, 9457, 1], [7785, 9457, 1], [7786, 9457, 1], [7787, 9457, 1], [7788, 9457, 1], [7789, 9457, 1], [7790, 9457, 1], [7791, 9457, 1], [7792, 9457, 1], [7793, 9457, 1], [7794, 9457, 1], [7795, 9457, 1], [7796, 9457, 1], [7797, 9457, 1], [7798, 9457, 1], [7799, 9457, 1], [7800, 9457, 1], [7801, 9457, 1], [7802, 9457, 1], [7803, 9457, 1], [7804, 9457, 1], [7805, 9457, 1], [7806, 9457, 1], [7807, 9457, 1], [7808, 9457, 1], [7809, 9457, 1], [7810, 9457, 1], [7811, 9457, 1], [7812, 9457, 1], [7813, 9457, 1], [7814, 9457, 1], [7815, 9457, 1], [7816, 9457, 1], [7817, 9457, 1], [7818, 9457, 1], [7819, 9457, 1], [7820, 9457, 1], [7821, 9457, 1], [7822, 9457, 1], [7823, 9457, 1], [7824, 9457, 1], [7825, 9457, 1], [7826, 9457, 1], [7827, 9457, 1], [7828, 9457, 1], [7829, 9457, 1], [7830, 9457, 1], [7831, 9457, 1], [7832, 9457, 1], [7833, 9457, 1], [7834, 9457, 1], [7835, 9457, 1], [7836, 9457, 1], [7837, 9457, 1], [7838, 9457, 1], [7839, 9457, 1], [7840, 9457, 1], [7841, 9457, 1], [7842, 9457, 1], [7843, 9457, 1], [7844, 9457, 1], [7845, 9457, 1], [7846, 9457, 1], [7847, 9457, 1], [7848, 9457, 1], [7849, 9457, 1], [7850, 9457, 1], [7851, 9457, 1], [7852, 9457, 1], [7853, 9457, 1], [7854, 9457, 1], [7855, 9457, 1], [7856, 9457, 1], [7857, 9457, 1], [7858, 9457, 1], [7859, 9457, 1], [7860, 9457, 1], [7861, 9457, 1], [7862, 9457, 1], [7863, 9457, 1], [7864, 9457, 1], [7865, 9457, 1], [7866, 9457, 1], [7867, 9457, 1], [7868, 9457, 1], [7869, 9457, 1], [7870, 9457, 1], [7871, 9457, 1], [7872, 9457, 1], [7873, 9457, 1], [7874, 9457, 1], [7875, 9457, 1], [7876, 9457, 1], [7877, 9457, 1], [7878, 9457, 1], [7879, 9457, 1], [7880, 9457, 1], [7881, 9457, 1], [7882, 9457, 1], [7883, 9457, 1], [7884, 9457, 1], [7885, 9457, 1], [7886, 9457, 1], [7887, 9457, 1], [7888, 9457, 1], [7889, 9457, 1], [7890, 9457, 1], [7891, 9457, 1], [7892, 9457, 1], [7893, 9457, 1], [7894, 9457, 1], [7895, 9457, 1], [7896, 9457, 1], [7897, 9457, 1], [7898, 9457, 1], [7899, 9457, 1], [7900, 9457, 1], [7901, 9457, 1], [7902, 9457, 1], [7903, 9457, 1], [7904, 9451, 1], [7905, 9451, 1], [7906, 9451, 1], [7907, 9451, 1], [7908, 9451, 1], [7909, 9451, 1], [7910, 9451, 1], [7911, 9451, 1], [7912, 9451, 1], [7913, 9451, 1], [7914, 9451, 1], [7915, 9451, 1], [7916, 9451, 1], [7917, 9451, 1], [7918, 9451, 1], [7919, 9451, 1], [7920, 9451, 1], [7921, 9451, 1], [7922, 9451, 1], [7923, 9451, 1], [7924, 9451, 1], [7925, 9451, 1], [7926, 9451, 1], [7927, 9451, 1], [7928, 9451, 1], [7929, 9451, 1], [7930, 9451, 1], [7931, 9451, 1], [7932, 9451, 1], [7933, 9451, 1], [7934, 9451, 1], [7935, 9451, 1], [7936, 9451, 1], [7937, 9451, 1], [7938, 9451, 1], [7939, 9451, 1], [7940, 9451, 1], [7941, 9451, 1], [7942, 9451, 1], [7943, 9451, 1], [7944, 9451, 1], [7945, 9451, 1], [7946, 9451, 1], [7947, 9451, 1], [7948, 9451, 1], [7949, 9451, 1], [7950, 9451, 1], [7951, 9451, 1], [7952, 9451, 1], [7953, 9451, 1], [7954, 9451, 1], [7955, 9451, 1], [7956, 9451, 1], [7957, 9451, 1], [7958, 9451, 1], [7959, 9451, 1], [7960, 9451, 1], [7961, 9451, 1], [7962, 9451, 1], [7963, 9451, 1], [7964, 9451, 1], [7965, 9451, 1], [7966, 9451, 1], [7967, 9451, 1], [7968, 9451, 1], [7969, 9451, 1], [7970, 9451, 1], [7971, 9451, 1], [7972, 9451, 1], [7973, 9451, 1], [7974, 9451, 1], [7975, 9451, 1], [7976, 9451, 1], [7977, 9451, 1], [7978, 9451, 1], [7979, 9451, 1], [7980, 9451, 1], [7981, 9451, 1], [7982, 9451, 1], [7983, 9451, 1], [7984, 9451, 1], [7985, 9451, 1], [7986, 9451, 1], [7987, 9451, 1], [7988, 9451, 1], [7989, 9451, 1], [7990, 9451, 1], [7991, 9451, 1], [7992, 9451, 1], [7993, 9451, 1], [7994, 9451, 1], [7995, 9451, 1], [7996, 9451, 1], [7997, 9451, 1], [7998, 9451, 1], [7999, 9451, 1], [8000, 9451, 1], [8001, 9451, 1], [8002, 9451, 1], [8003, 9451, 1], [8004, 9451, 1], [8005, 9451, 1], [8006, 9451, 1], [8007, 9451, 1], [8008, 9451, 1], [8009, 9451, 1], [8010, 9451, 1], [8011, 9451, 1], [8012, 9451, 1], [8013, 9451, 1], [8014, 9451, 1], [8015, 9451, 1], [8016, 9451, 1], [8017, 9451, 1], [8018, 9451, 1], [8019, 9451, 1], [8020, 9451, 1], [8021, 9451, 1], [8022, 9451, 1], [8023, 9451, 1], [8024, 9451, 1], [8025, 9451, 1], [8026, 9451, 1], [8027, 9451, 1], [8028, 9451, 1], [8029, 9451, 1], [8030, 9451, 1], [8031, 9451, 1], [8032, 9451, 1], [8033, 9451, 1], [8034, 9451, 1], [8035, 9451, 1], [8036, 9451, 1], [8037, 9451, 1], [8038, 9451, 1], [8039, 9451, 1], [8040, 9451, 1], [8041, 9451, 1], [8042, 9451, 1], [8043, 9451, 1], [8044, 9470, 1], [8045, 9470, 1], [8046, 9470, 1], [8047, 9470, 1], [8048, 9470, 1], [8049, 9470, 1], [8050, 9470, 1], [8051, 9470, 1], [8052, 9470, 1], [8053, 9470, 1], [8054, 9470, 1], [8055, 9470, 1], [8056, 9470, 1], [8057, 9470, 1], [8058, 9470, 1], [8059, 9470, 1], [8060, 9470, 1], [8061, 9470, 1], [8062, 9470, 1], [8063, 9470, 1], [8064, 9470, 1], [8065, 9470, 1], [8066, 9470, 1], [8067, 9470, 1], [8068, 9470, 1], [8069, 9470, 1], [8070, 9470, 1], [8071, 9470, 1], [8072, 9470, 1], [8073, 9470, 1], [8074, 9470, 1], [8075, 9470, 1], [8076, 9470, 1], [8077, 9470, 1], [8078, 9470, 1], [8079, 9470, 1], [8080, 9470, 1], [8081, 9470, 1], [8082, 9470, 1], [8083, 9470, 1], [8084, 9470, 1], [8085, 9470, 1], [8086, 9470, 1], [8087, 9470, 1], [8088, 9470, 1], [8089, 9470, 1], [8090, 9470, 1], [8091, 9470, 1], [8092, 9470, 1], [8093, 9470, 1], [8094, 9470, 1], [8095, 9470, 1], [8096, 9470, 1], [8097, 9470, 1], [8098, 9470, 1], [8099, 9470, 1], [8100, 9470, 1], [8101, 9470, 1], [8102, 9470, 1], [8103, 9470, 1], [8104, 9470, 1], [8105, 9470, 1], [8106, 9470, 1], [8107, 9470, 1], [8108, 9470, 1], [8109, 9470, 1], [8110, 9470, 1], [8111, 9470, 1], [8112, 9470, 1], [8113, 9470, 1], [8114, 9470, 1], [8115, 9470, 1], [8116, 9470, 1], [8117, 9470, 1], [8118, 9470, 1], [8119, 9470, 1], [8120, 9470, 1], [8121, 9470, 1], [8122, 9470, 1], [8123, 9470, 1], [8124, 9470, 1], [8125, 9470, 1], [8126, 9470, 1], [8127, 9470, 1], [8128, 9470, 1], [8129, 9470, 1], [8130, 9470, 1], [8131, 9470, 1], [8132, 9470, 1], [8133, 9470, 1], [8134, 9470, 1], [8135, 9470, 1], [8136, 9470, 1], [8137, 9470, 1], [8138, 9470, 1], [8139, 9470, 1], [8140, 9470, 1], [8141, 9470, 1], [8142, 9470, 1], [8143, 9470, 1], [8144, 9470, 1], [8145, 9470, 1], [8146, 9470, 1], [8147, 9470, 1], [8148, 9470, 1], [8149, 9470, 1], [8150, 9470, 1], [8151, 9470, 1], [8152, 9470, 1], [8153, 9470, 1], [8154, 9470, 1], [8155, 9470, 1], [8156, 9470, 1], [8157, 9470, 1], [8158, 9470, 1], [8159, 9470, 1], [8160, 9470, 1], [8161, 9470, 1], [8162, 9470, 1], [8163, 9470, 1], [8164, 9470, 1], [8165, 9470, 1], [8166, 9470, 1], [8167, 9470, 1], [8168, 9470, 1], [8169, 9470, 1], [8170, 9470, 1], [8171, 9470, 1], [8172, 9470, 1], [8173, 9470, 1], [8174, 9470, 1], [8175, 9470, 1], [8176, 9470, 1], [8177, 9470, 1], [8178, 9470, 1], [8179, 9470, 1], [8180, 9470, 1], [8181, 9470, 1], [8182, 9470, 1], [8183, 9470, 1], [8184, 9470, 1], [8185, 9470, 1], [8186, 9470, 1], [8187, 9470, 1], [8188, 9470, 1], [8189, 9470, 1], [8190, 9470, 1], [8191, 9470, 1], [8192, 9470, 1], [8193, 9470, 1], [8194, 9470, 1], [8195, 9470, 1], [8196, 9470, 1], [8197, 9470, 1], [8198, 9470, 1], [8199, 9470, 1], [8200, 9470, 1], [8201, 9470, 1], [8202, 9470, 1], [8203, 9470, 1], [8204, 9470, 1], [8205, 9470, 1], [8206, 9470, 1], [8207, 9470, 1], [8208, 9470, 1], [8209, 9470, 1], [8210, 9470, 1], [8211, 9470, 1], [8212, 9470, 1], [8213, 9470, 1], [8214, 9470, 1], [8215, 9470, 1], [8216, 9470, 1], [8217, 9470, 1], [8218, 9470, 1], [8219, 9470, 1], [8220, 9470, 1], [8221, 9470, 1], [8222, 9470, 1], [8223, 9470, 1], [8224, 9470, 1], [8225, 9470, 1], [8226, 9470, 1], [8227, 9470, 1], [8228, 9470, 1], [8229, 9470, 1], [8230, 9470, 1], [8231, 9470, 1], [8232, 9470, 1], [8233, 9470, 1], [8234, 9470, 1], [8235, 9470, 1], [8236, 9470, 1], [8237, 9470, 1], [8238, 9470, 1], [8239, 9470, 1], [8240, 9470, 1], [8241, 9470, 1], [8242, 9470, 1], [8243, 9470, 1], [8244, 9470, 1], [8245, 9470, 1], [8246, 9470, 1], [8247, 9470, 1], [8248, 9470, 1], [8249, 9470, 1], [8250, 9470, 1], [8251, 9470, 1], [8252, 9470, 1], [8253, 9470, 1], [8254, 9470, 1], [8255, 9470, 1], [8256, 9470, 1], [8257, 9470, 1], [8258, 9470, 1], [8259, 9470, 1], [8260, 9470, 1], [8261, 9470, 1], [8262, 9470, 1], [8263, 9470, 1], [8264, 9470, 1], [8265, 9470, 1], [8266, 9470, 1], [8267, 9470, 1], [8268, 9470, 1], [8269, 9470, 1], [8270, 9470, 1], [8271, 9470, 1], [8272, 9470, 1], [8273, 9470, 1], [8274, 9470, 1], [8275, 9470, 1], [8276, 9470, 1], [8277, 9470, 1], [8278, 9470, 1], [8279, 9470, 1], [8280, 9470, 1], [8281, 9470, 1], [8282, 9470, 1], [8283, 9470, 1], [8284, 9470, 1], [8285, 9470, 1], [8286, 9470, 1], [8287, 9470, 1], [8288, 9470, 1], [8289, 9470, 1], [8290, 9470, 1], [8291, 9470, 1], [8292, 9470, 1], [8293, 9470, 1], [8294, 9470, 1], [8295, 9470, 1], [8296, 9470, 1], [8297, 9470, 1], [8298, 9470, 1], [8299, 9470, 1], [8300, 9470, 1], [8301, 9470, 1], [8302, 9470, 1], [8303, 9470, 1], [8304, 9470, 1], [8305, 9470, 1], [8306, 9470, 1], [8307, 9470, 1], [8308, 9470, 1], [8309, 9470, 1], [8310, 9470, 1], [8311, 9470, 1], [8312, 9470, 1], [8313, 9470, 1], [8314, 9470, 1], [8315, 9470, 1], [8316, 9470, 1], [8317, 9470, 1], [8318, 9470, 1], [8319, 9470, 1], [8320, 9470, 1], [8321, 9470, 1], [8322, 9470, 1], [8323, 9470, 1], [8324, 9451, 1], [8325, 9451, 1], [8326, 9451, 1], [8327, 9451, 1], [8328, 9451, 1], [8329, 9451, 1], [8330, 9451, 1], [8331, 9451, 1], [8332, 9451, 1], [8333, 9451, 1], [8334, 9451, 1], [8335, 9451, 1], [8336, 9451, 1], [8337, 9451, 1], [8338, 9451, 1], [8339, 9451, 1], [8340, 9451, 1], [8341, 9451, 1], [8342, 9451, 1], [8343, 9451, 1], [8344, 9451, 1], [8345, 9451, 1], [8346, 9451, 1], [8347, 9451, 1], [8348, 9451, 1], [8349, 9451, 1], [8350, 9451, 1], [8351, 9451, 1], [8352, 9451, 1], [8353, 9451, 1], [8354, 9451, 1], [8355, 9451, 1], [8356, 9451, 1], [8357, 9451, 1], [8358, 9451, 1], [8359, 9451, 1], [8360, 9451, 1], [8361, 9451, 1], [8362, 9451, 1], [8363, 9451, 1], [8364, 9451, 1], [8365, 9451, 1], [8366, 9451, 1], [8367, 9451, 1], [8368, 9451, 1], [8369, 9451, 1], [8370, 9451, 1], [8371, 9451, 1], [8372, 9451, 1], [8373, 9451, 1], [8374, 9451, 1], [8375, 9451, 1], [8376, 9451, 1], [8377, 9451, 1], [8378, 9451, 1], [8379, 9451, 1], [8380, 9451, 1], [8381, 9451, 1], [8382, 9451, 1], [8383, 9451, 1], [8384, 9451, 1], [8385, 9451, 1], [8386, 9451, 1], [8387, 9451, 1], [8388, 9451, 1], [8389, 9451, 1], [8390, 9451, 1], [8391, 9451, 1], [8392, 9451, 1], [8393, 9451, 1], [8394, 9451, 1], [8395, 9451, 1], [8396, 9451, 1], [8397, 9451, 1], [8398, 9451, 1], [8399, 9451, 1], [8400, 9451, 1], [8401, 9451, 1], [8402, 9451, 1], [8403, 9451, 1], [8404, 9451, 1], [8405, 9451, 1], [8406, 9451, 1], [8407, 9451, 1], [8408, 9451, 1], [8409, 9451, 1], [8410, 9451, 1], [8411, 9451, 1], [8412, 9451, 1], [8413, 9451, 1], [8414, 9451, 1], [8415, 9451, 1], [8416, 9451, 1], [8417, 9451, 1], [8418, 9451, 1], [8419, 9451, 1], [8420, 9451, 1], [8421, 9451, 1], [8422, 9451, 1], [8423, 9451, 1], [8424, 9451, 1], [8425, 9451, 1], [8426, 9451, 1], [8427, 9451, 1], [8428, 9451, 1], [8429, 9451, 1], [8430, 9451, 1], [8431, 9451, 1], [8432, 9451, 1], [8433, 9451, 1], [8434, 9451, 1], [8435, 9451, 1], [8436, 9451, 1], [8437, 9451, 1], [8438, 9451, 1], [8439, 9451, 1], [8440, 9451, 1], [8441, 9451, 1], [8442, 9451, 1], [8443, 9451, 1], [8444, 9451, 1], [8445, 9451, 1], [8446, 9451, 1], [8447, 9451, 1], [8448, 9451, 1], [8449, 9451, 1], [8450, 9451, 1], [8451, 9451, 1], [8452, 9451, 1], [8453, 9451, 1], [8454, 9451, 1], [8455, 9451, 1], [8456, 9451, 1], [8457, 9451, 1], [8458, 9451, 1], [8459, 9451, 1], [8460, 9451, 1], [8461, 9451, 1], [8462, 9451, 1], [8463, 9451, 1], [8464, 9457, 1], [8465, 9457, 1], [8466, 9457, 1], [8467, 9457, 1], [8468, 9457, 1], [8469, 9457, 1], [8470, 9457, 1], [8471, 9457, 1], [8472, 9457, 1], [8473, 9457, 1], [8474, 9457, 1], [8475, 9457, 1], [8476, 9457, 1], [8477, 9457, 1], [8478, 9457, 1], [8479, 9457, 1], [8480, 9457, 1], [8481, 9457, 1], [8482, 9457, 1], [8483, 9457, 1], [8484, 9457, 1], [8485, 9457, 1], [8486, 9457, 1], [8487, 9457, 1], [8488, 9457, 1], [8489, 9457, 1], [8490, 9457, 1], [8491, 9457, 1], [8492, 9457, 1], [8493, 9457, 1], [8494, 9457, 1], [8495, 9457, 1], [8496, 9457, 1], [8497, 9457, 1], [8498, 9457, 1], [8499, 9457, 1], [8500, 9457, 1], [8501, 9457, 1], [8502, 9457, 1], [8503, 9457, 1], [8504, 9457, 1], [8505, 9457, 1], [8506, 9457, 1], [8507, 9457, 1], [8508, 9457, 1], [8509, 9457, 1], [8510, 9457, 1], [8511, 9457, 1], [8512, 9457, 1], [8513, 9457, 1], [8514, 9457, 1], [8515, 9457, 1], [8516, 9457, 1], [8517, 9457, 1], [8518, 9457, 1], [8519, 9457, 1], [8520, 9457, 1], [8521, 9457, 1], [8522, 9457, 1], [8523, 9457, 1], [8524, 9457, 1], [8525, 9457, 1], [8526, 9457, 1], [8527, 9457, 1], [8528, 9457, 1], [8529, 9457, 1], [8530, 9457, 1], [8531, 9457, 1], [8532, 9457, 1], [8533, 9457, 1], [8534, 9457, 1], [8535, 9457, 1], [8536, 9457, 1], [8537, 9457, 1], [8538, 9457, 1], [8539, 9457, 1], [8540, 9457, 1], [8541, 9457, 1], [8542, 9457, 1], [8543, 9457, 1], [8544, 9457, 1], [8545, 9457, 1], [8546, 9457, 1], [8547, 9457, 1], [8548, 9457, 1], [8549, 9457, 1], [8550, 9457, 1], [8551, 9457, 1], [8552, 9457, 1], [8553, 9457, 1], [8554, 9457, 1], [8555, 9457, 1], [8556, 9457, 1], [8557, 9457, 1], [8558, 9457, 1], [8559, 9457, 1], [8560, 9457, 1], [8561, 9457, 1], [8562, 9457, 1], [8563, 9457, 1], [8564, 9457, 1], [8565, 9457, 1], [8566, 9457, 1], [8567, 9457, 1], [8568, 9457, 1], [8569, 9457, 1], [8570, 9457, 1], [8571, 9457, 1], [8572, 9457, 1], [8573, 9457, 1], [8574, 9457, 1], [8575, 9457, 1], [8576, 9457, 1], [8577, 9457, 1], [8578, 9457, 1], [8579, 9457, 1], [8580, 9457, 1], [8581, 9457, 1], [8582, 9457, 1], [8583, 9457, 1], [8584, 9457, 1], [8585, 9457, 1], [8586, 9457, 1], [8587, 9457, 1], [8588, 9457, 1], [8589, 9457, 1], [8590, 9457, 1], [8591, 9457, 1], [8592, 9457, 1], [8593, 9457, 1], [8594, 9457, 1], [8595, 9457, 1], [8596, 9457, 1], [8597, 9457, 1], [8598, 9457, 1], [8599, 9457, 1], [8600, 9457, 1], [8601, 9457, 1], [8602, 9457, 1], [8603, 9457, 1], [8604, 9454, 1], [8605, 9454, 1], [8606, 9454, 1], [8607, 9454, 1], [8608, 9454, 1], [8609, 9454, 1], [8610, 9454, 1], [8611, 9454, 1], [8612, 9454, 1], [8613, 9454, 1], [8614, 9454, 1], [8615, 9454, 1], [8616, 9454, 1], [8617, 9454, 1], [8618, 9454, 1], [8619, 9454, 1], [8620, 9454, 1], [8621, 9454, 1], [8622, 9454, 1], [8623, 9454, 1], [8624, 9454, 1], [8625, 9454, 1], [8626, 9454, 1], [8627, 9454, 1], [8628, 9454, 1], [8629, 9454, 1], [8630, 9454, 1], [8631, 9454, 1], [8632, 9454, 1], [8633, 9454, 1], [8634, 9454, 1], [8635, 9454, 1], [8636, 9454, 1], [8637, 9454, 1], [8638, 9454, 1], [8639, 9454, 1], [8640, 9454, 1], [8641, 9454, 1], [8642, 9454, 1], [8643, 9454, 1], [8644, 9454, 1], [8645, 9454, 1], [8646, 9454, 1], [8647, 9454, 1], [8648, 9454, 1], [8649, 9454, 1], [8650, 9454, 1], [8651, 9454, 1], [8652, 9454, 1], [8653, 9454, 1], [8654, 9454, 1], [8655, 9454, 1], [8656, 9454, 1], [8657, 9454, 1], [8658, 9454, 1], [8659, 9454, 1], [8660, 9454, 1], [8661, 9454, 1], [8662, 9454, 1], [8663, 9454, 1], [8664, 9454, 1], [8665, 9454, 1], [8666, 9454, 1], [8667, 9454, 1], [8668, 9454, 1], [8669, 9454, 1], [8670, 9454, 1], [8671, 9454, 1], [8672, 9454, 1], [8673, 9454, 1], [8674, 9454, 1], [8675, 9454, 1], [8676, 9454, 1], [8677, 9454, 1], [8678, 9454, 1], [8679, 9454, 1], [8680, 9454, 1], [8681, 9454, 1], [8682, 9454, 1], [8683, 9454, 1], [8684, 9454, 1], [8685, 9454, 1], [8686, 9454, 1], [8687, 9454, 1], [8688, 9454, 1], [8689, 9454, 1], [8690, 9454, 1], [8691, 9454, 1], [8692, 9454, 1], [8693, 9454, 1], [8694, 9454, 1], [8695, 9454, 1], [8696, 9454, 1], [8697, 9454, 1], [8698, 9454, 1], [8699, 9454, 1], [8700, 9454, 1], [8701, 9454, 1], [8702, 9454, 1], [8703, 9454, 1], [8704, 9454, 1], [8705, 9454, 1], [8706, 9454, 1], [8707, 9454, 1], [8708, 9454, 1], [8709, 9454, 1], [8710, 9454, 1], [8711, 9454, 1], [8712, 9454, 1], [8713, 9454, 1], [8714, 9454, 1], [8715, 9454, 1], [8716, 9454, 1], [8717, 9454, 1], [8718, 9454, 1], [8719, 9454, 1], [8720, 9454, 1], [8721, 9454, 1], [8722, 9454, 1], [8723, 9454, 1], [8724, 9454, 1], [8725, 9454, 1], [8726, 9454, 1], [8727, 9454, 1], [8728, 9454, 1], [8729, 9454, 1], [8730, 9454, 1], [8731, 9454, 1], [8732, 9454, 1], [8733, 9454, 1], [8734, 9454, 1], [8735, 9454, 1], [8736, 9454, 1], [8737, 9454, 1], [8738, 9454, 1], [8739, 9454, 1], [8740, 9454, 1], [8741, 9454, 1], [8742, 9454, 1], [8743, 9454, 1], [8744, 9450, 1], [8745, 9450, 1], [8746, 9450, 1], [8747, 9450, 1], [8748, 9450, 1], [8749, 9450, 1], [8750, 9450, 1], [8751, 9450, 1], [8752, 9450, 1], [8753, 9450, 1], [8754, 9450, 1], [8755, 9450, 1], [8756, 9450, 1], [8757, 9450, 1], [8758, 9450, 1], [8759, 9450, 1], [8760, 9450, 1], [8761, 9450, 1], [8762, 9450, 1], [8763, 9450, 1], [8764, 9450, 1], [8765, 9450, 1], [8766, 9450, 1], [8767, 9450, 1], [8768, 9450, 1], [8769, 9450, 1], [8770, 9450, 1], [8771, 9450, 1], [8772, 9450, 1], [8773, 9450, 1], [8774, 9450, 1], [8775, 9450, 1], [8776, 9450, 1], [8777, 9450, 1], [8778, 9450, 1], [8779, 9450, 1], [8780, 9450, 1], [8781, 9450, 1], [8782, 9450, 1], [8783, 9450, 1], [8784, 9450, 1], [8785, 9450, 1], [8786, 9450, 1], [8787, 9450, 1], [8788, 9450, 1], [8789, 9450, 1], [8790, 9450, 1], [8791, 9450, 1], [8792, 9450, 1], [8793, 9450, 1], [8794, 9450, 1], [8795, 9450, 1], [8796, 9450, 1], [8797, 9450, 1], [8798, 9450, 1], [8799, 9450, 1], [8800, 9450, 1], [8801, 9450, 1], [8802, 9450, 1], [8803, 9450, 1], [8804, 9450, 1], [8805, 9450, 1], [8806, 9450, 1], [8807, 9450, 1], [8808, 9450, 1], [8809, 9450, 1], [8810, 9450, 1], [8811, 9450, 1], [8812, 9450, 1], [8813, 9450, 1], [8814, 9450, 1], [8815, 9450, 1], [8816, 9450, 1], [8817, 9450, 1], [8818, 9450, 1], [8819, 9450, 1], [8820, 9450, 1], [8821, 9450, 1], [8822, 9450, 1], [8823, 9450, 1], [8824, 9450, 1], [8825, 9450, 1], [8826, 9450, 1], [8827, 9450, 1], [8828, 9450, 1], [8829, 9450, 1], [8830, 9450, 1], [8831, 9450, 1], [8832, 9450, 1], [8833, 9450, 1], [8834, 9450, 1], [8835, 9450, 1], [8836, 9450, 1], [8837, 9450, 1], [8838, 9450, 1], [8839, 9450, 1], [8840, 9450, 1], [8841, 9450, 1], [8842, 9450, 1], [8843, 9450, 1], [8844, 9450, 1], [8845, 9450, 1], [8846, 9450, 1], [8847, 9450, 1], [8848, 9450, 1], [8849, 9450, 1], [8850, 9450, 1], [8851, 9450, 1], [8852, 9450, 1], [8853, 9450, 1], [8854, 9450, 1], [8855, 9450, 1], [8856, 9450, 1], [8857, 9450, 1], [8858, 9450, 1], [8859, 9450, 1], [8860, 9450, 1], [8861, 9450, 1], [8862, 9450, 1], [8863, 9450, 1], [8864, 9450, 1], [8865, 9450, 1], [8866, 9450, 1], [8867, 9450, 1], [8868, 9450, 1], [8869, 9450, 1], [8870, 9450, 1], [8871, 9450, 1], [8872, 9450, 1], [8873, 9450, 1], [8874, 9450, 1], [8875, 9450, 1], [8876, 9450, 1], [8877, 9450, 1], [8878, 9450, 1], [8879, 9450, 1], [8880, 9450, 1], [8881, 9450, 1], [8882, 9450, 1], [8883, 9450, 1], [8884, 9466, 1], [8885, 9466, 1], [8886, 9466, 1], [8887, 9466, 1], [8888, 9466, 1], [8889, 9466, 1], [8890, 9466, 1], [8891, 9466, 1], [8892, 9466, 1], [8893, 9466, 1], [8894, 9466, 1], [8895, 9466, 1], [8896, 9466, 1], [8897, 9466, 1], [8898, 9466, 1], [8899, 9466, 1], [8900, 9466, 1], [8901, 9466, 1], [8902, 9466, 1], [8903, 9466, 1], [8904, 9466, 1], [8905, 9466, 1], [8906, 9466, 1], [8907, 9466, 1], [8908, 9466, 1], [8909, 9466, 1], [8910, 9466, 1], [8911, 9466, 1], [8912, 9466, 1], [8913, 9466, 1], [8914, 9466, 1], [8915, 9466, 1], [8916, 9466, 1], [8917, 9466, 1], [8918, 9466, 1], [8919, 9466, 1], [8920, 9466, 1], [8921, 9466, 1], [8922, 9466, 1], [8923, 9466, 1], [8924, 9466, 1], [8925, 9466, 1], [8926, 9466, 1], [8927, 9466, 1], [8928, 9466, 1], [8929, 9466, 1], [8930, 9466, 1], [8931, 9466, 1], [8932, 9466, 1], [8933, 9466, 1], [8934, 9466, 1], [8935, 9466, 1], [8936, 9466, 1], [8937, 9466, 1], [8938, 9466, 1], [8939, 9466, 1], [8940, 9466, 1], [8941, 9466, 1], [8942, 9466, 1], [8943, 9466, 1], [8944, 9466, 1], [8945, 9466, 1], [8946, 9466, 1], [8947, 9466, 1], [8948, 9466, 1], [8949, 9466, 1], [8950, 9466, 1], [8951, 9466, 1], [8952, 9466, 1], [8953, 9466, 1], [8954, 9466, 1], [8955, 9466, 1], [8956, 9466, 1], [8957, 9466, 1], [8958, 9466, 1], [8959, 9466, 1], [8960, 9466, 1], [8961, 9466, 1], [8962, 9466, 1], [8963, 9466, 1], [8964, 9466, 1], [8965, 9466, 1], [8966, 9466, 1], [8967, 9466, 1], [8968, 9466, 1], [8969, 9466, 1], [8970, 9466, 1], [8971, 9466, 1], [8972, 9466, 1], [8973, 9466, 1], [8974, 9466, 1], [8975, 9466, 1], [8976, 9466, 1], [8977, 9466, 1], [8978, 9466, 1], [8979, 9466, 1], [8980, 9466, 1], [8981, 9466, 1], [8982, 9466, 1], [8983, 9466, 1], [8984, 9466, 1], [8985, 9466, 1], [8986, 9466, 1], [8987, 9466, 1], [8988, 9466, 1], [8989, 9466, 1], [8990, 9466, 1], [8991, 9466, 1], [8992, 9466, 1], [8993, 9466, 1], [8994, 9466, 1], [8995, 9466, 1], [8996, 9466, 1], [8997, 9466, 1], [8998, 9466, 1], [8999, 9466, 1], [9000, 9466, 1], [9001, 9466, 1], [9002, 9466, 1], [9003, 9466, 1], [9004, 9466, 1], [9005, 9466, 1], [9006, 9466, 1], [9007, 9466, 1], [9008, 9466, 1], [9009, 9466, 1], [9010, 9466, 1], [9011, 9466, 1], [9012, 9466, 1], [9013, 9466, 1], [9014, 9466, 1], [9015, 9466, 1], [9016, 9466, 1], [9017, 9466, 1], [9018, 9466, 1], [9019, 9466, 1], [9020, 9466, 1], [9021, 9466, 1], [9022, 9466, 1], [9023, 9466, 1], [9024, 9466, 1], [9025, 9466, 1], [9026, 9466, 1], [9027, 9466, 1], [9028, 9466, 1], [9029, 9466, 1], [9030, 9466, 1], [9031, 9466, 1], [9032, 9466, 1], [9033, 9466, 1], [9034, 9466, 1], [9035, 9466, 1], [9036, 9466, 1], [9037, 9466, 1], [9038, 9466, 1], [9039, 9466, 1], [9040, 9466, 1], [9041, 9466, 1], [9042, 9466, 1], [9043, 9466, 1], [9044, 9466, 1], [9045, 9466, 1], [9046, 9466, 1], [9047, 9466, 1], [9048, 9466, 1], [9049, 9466, 1], [9050, 9466, 1], [9051, 9466, 1], [9052, 9466, 1], [9053, 9466, 1], [9054, 9466, 1], [9055, 9466, 1], [9056, 9466, 1], [9057, 9466, 1], [9058, 9466, 1], [9059, 9466, 1], [9060, 9466, 1], [9061, 9466, 1], [9062, 9466, 1], [9063, 9466, 1], [9064, 9466, 1], [9065, 9466, 1], [9066, 9466, 1], [9067, 9466, 1], [9068, 9466, 1], [9069, 9466, 1], [9070, 9466, 1], [9071, 9466, 1], [9072, 9466, 1], [9073, 9466, 1], [9074, 9466, 1], [9075, 9466, 1], [9076, 9466, 1], [9077, 9466, 1], [9078, 9466, 1], [9079, 9466, 1], [9080, 9466, 1], [9081, 9466, 1], [9082, 9466, 1], [9083, 9466, 1], [9084, 9466, 1], [9085, 9466, 1], [9086, 9466, 1], [9087, 9466, 1], [9088, 9466, 1], [9089, 9466, 1], [9090, 9466, 1], [9091, 9466, 1], [9092, 9466, 1], [9093, 9466, 1], [9094, 9466, 1], [9095, 9466, 1], [9096, 9466, 1], [9097, 9466, 1], [9098, 9466, 1], [9099, 9466, 1], [9100, 9466, 1], [9101, 9466, 1], [9102, 9466, 1], [9103, 9466, 1], [9104, 9466, 1], [9105, 9466, 1], [9106, 9466, 1], [9107, 9466, 1], [9108, 9466, 1], [9109, 9466, 1], [9110, 9466, 1], [9111, 9466, 1], [9112, 9466, 1], [9113, 9466, 1], [9114, 9466, 1], [9115, 9466, 1], [9116, 9466, 1], [9117, 9466, 1], [9118, 9466, 1], [9119, 9466, 1], [9120, 9466, 1], [9121, 9466, 1], [9122, 9466, 1], [9123, 9466, 1], [9124, 9466, 1], [9125, 9466, 1], [9126, 9466, 1], [9127, 9466, 1], [9128, 9466, 1], [9129, 9466, 1], [9130, 9466, 1], [9131, 9466, 1], [9132, 9466, 1], [9133, 9466, 1], [9134, 9466, 1], [9135, 9466, 1], [9136, 9466, 1], [9137, 9466, 1], [9138, 9466, 1], [9139, 9466, 1], [9140, 9466, 1], [9141, 9466, 1], [9142, 9466, 1], [9143, 9466, 1], [9144, 9466, 1], [9145, 9466, 1], [9146, 9466, 1], [9147, 9466, 1], [9148, 9466, 1], [9149, 9466, 1], [9150, 9466, 1], [9151, 9466, 1], [9152, 9466, 1], [9153, 9466, 1], [9154, 9466, 1], [9155, 9466, 1], [9156, 9466, 1], [9157, 9466, 1], [9158, 9466, 1], [9159, 9466, 1], [9160, 9466, 1], [9161, 9466, 1], [9162, 9466, 1], [9163, 9466, 1], [9164, 9450, 1], [9165, 9450, 1], [9166, 9450, 1], [9167, 9450, 1], [9168, 9450, 1], [9169, 9450, 1], [9170, 9450, 1], [9171, 9450, 1], [9172, 9450, 1], [9173, 9450, 1], [9174, 9450, 1], [9175, 9450, 1], [9176, 9450, 1], [9177, 9450, 1], [9178, 9450, 1], [9179, 9450, 1], [9180, 9450, 1], [9181, 9450, 1], [9182, 9450, 1], [9183, 9450, 1], [9184, 9450, 1], [9185, 9450, 1], [9186, 9450, 1], [9187, 9450, 1], [9188, 9450, 1], [9189, 9450, 1], [9190, 9450, 1], [9191, 9450, 1], [9192, 9450, 1], [9193, 9450, 1], [9194, 9450, 1], [9195, 9450, 1], [9196, 9450, 1], [9197, 9450, 1], [9198, 9450, 1], [9199, 9450, 1], [9200, 9450, 1], [9201, 9450, 1], [9202, 9450, 1], [9203, 9450, 1], [9204, 9450, 1], [9205, 9450, 1], [9206, 9450, 1], [9207, 9450, 1], [9208, 9450, 1], [9209, 9450, 1], [9210, 9450, 1], [9211, 9450, 1], [9212, 9450, 1], [9213, 9450, 1], [9214, 9450, 1], [9215, 9450, 1], [9216, 9450, 1], [9217, 9450, 1], [9218, 9450, 1], [9219, 9450, 1], [9220, 9450, 1], [9221, 9450, 1], [9222, 9450, 1], [9223, 9450, 1], [9224, 9450, 1], [9225, 9450, 1], [9226, 9450, 1], [9227, 9450, 1], [9228, 9450, 1], [9229, 9450, 1], [9230, 9450, 1], [9231, 9450, 1], [9232, 9450, 1], [9233, 9450, 1], [9234, 9450, 1], [9235, 9450, 1], [9236, 9450, 1], [9237, 9450, 1], [9238, 9450, 1], [9239, 9450, 1], [9240, 9450, 1], [9241, 9450, 1], [9242, 9450, 1], [9243, 9450, 1], [9244, 9450, 1], [9245, 9450, 1], [9246, 9450, 1], [9247, 9450, 1], [9248, 9450, 1], [9249, 9450, 1], [9250, 9450, 1], [9251, 9450, 1], [9252, 9450, 1], [9253, 9450, 1], [9254, 9450, 1], [9255, 9450, 1], [9256, 9450, 1], [9257, 9450, 1], [9258, 9450, 1], [9259, 9450, 1], [9260, 9450, 1], [9261, 9450, 1], [9262, 9450, 1], [9263, 9450, 1], [9264, 9450, 1], [9265, 9450, 1], [9266, 9450, 1], [9267, 9450, 1], [9268, 9450, 1], [9269, 9450, 1], [9270, 9450, 1], [9271, 9450, 1], [9272, 9450, 1], [9273, 9450, 1], [9274, 9450, 1], [9275, 9450, 1], [9276, 9450, 1], [9277, 9450, 1], [9278, 9450, 1], [9279, 9450, 1], [9280, 9450, 1], [9281, 9450, 1], [9282, 9450, 1], [9283, 9450, 1], [9284, 9450, 1], [9285, 9450, 1], [9286, 9450, 1], [9287, 9450, 1], [9288, 9450, 1], [9289, 9450, 1], [9290, 9450, 1], [9291, 9450, 1], [9292, 9450, 1], [9293, 9450, 1], [9294, 9450, 1], [9295, 9450, 1], [9296, 9450, 1], [9297, 9450, 1], [9298, 9450, 1], [9299, 9450, 1], [9300, 9450, 1], [9301, 9450, 1], [9302, 9450, 1], [9303, 9450, 1], [9304, 9454, 1], [9305, 9454, 1], [9306, 9454, 1], [9307, 9454, 1], [9308, 9454, 1], [9309, 9454, 1], [9310, 9454, 1], [9311, 9454, 1], [9312, 9454, 1], [9313, 9454, 1], [9314, 9454, 1], [9315, 9454, 1], [9316, 9454, 1], [9317, 9454, 1], [9318, 9454, 1], [9319, 9454, 1], [9320, 9454, 1], [9321, 9454, 1], [9322, 9454, 1], [9323, 9454, 1], [9324, 9454, 1], [9325, 9454, 1], [9326, 9454, 1], [9327, 9454, 1], [9328, 9454, 1], [9329, 9454, 1], [9330, 9454, 1], [9331, 9454, 1], [9332, 9454, 1], [9333, 9454, 1], [9334, 9454, 1], [9335, 9454, 1], [9336, 9454, 1], [9337, 9454, 1], [9338, 9454, 1], [9339, 9454, 1], [9340, 9454, 1], [9341, 9454, 1], [9342, 9454, 1], [9343, 9454, 1], [9344, 9454, 1], [9345, 9454, 1], [9346, 9454, 1], [9347, 9454, 1], [9348, 9454, 1], [9349, 9454, 1], [9350, 9454, 1], [9351, 9454, 1], [9352, 9454, 1], [9353, 9454, 1], [9354, 9454, 1], [9355, 9454, 1], [9356, 9454, 1], [9357, 9454, 1], [9358, 9454, 1], [9359, 9454, 1], [9360, 9454, 1], [9361, 9454, 1], [9362, 9454, 1], [9363, 9454, 1], [9364, 9454, 1], [9365, 9454, 1], [9366, 9454, 1], [9367, 9454, 1], [9368, 9454, 1], [9369, 9454, 1], [9370, 9454, 1], [9371, 9454, 1], [9372, 9454, 1], [9373, 9454, 1], [9374, 9454, 1], [9375, 9454, 1], [9376, 9454, 1], [9377, 9454, 1], [9378, 9454, 1], [9379, 9454, 1], [9380, 9454, 1], [9381, 9454, 1], [9382, 9454, 1], [9383, 9454, 1], [9384, 9454, 1], [9385, 9454, 1], [9386, 9454, 1], [9387, 9454, 1], [9388, 9454, 1], [9389, 9454, 1], [9390, 9454, 1], [9391, 9454, 1], [9392, 9454, 1], [9393, 9454, 1], [9394, 9454, 1], [9395, 9454, 1], [9396, 9454, 1], [9397, 9454, 1], [9398, 9454, 1], [9399, 9454, 1], [9400, 9454, 1], [9401, 9454, 1], [9402, 9454, 1], [9403, 9454, 1], [9404, 9454, 1], [9405, 9454, 1], [9406, 9454, 1], [9407, 9454, 1], [9408, 9454, 1], [9409, 9454, 1], [9410, 9454, 1], [9411, 9454, 1], [9412, 9454, 1], [9413, 9454, 1], [9414, 9454, 1], [9415, 9454, 1], [9416, 9454, 1], [9417, 9454, 1], [9418, 9454, 1], [9419, 9454, 1], [9420, 9454, 1], [9421, 9454, 1], [9422, 9454, 1], [9423, 9454, 1], [9424, 9454, 1], [9425, 9454, 1], [9426, 9454, 1], [9427, 9454, 1], [9428, 9454, 1], [9429, 9454, 1], [9430, 9454, 1], [9431, 9454, 1], [9432, 9454, 1], [9433, 9454, 1], [9434, 9454, 1], [9435, 9454, 1], [9436, 9454, 1], [9437, 9454, 1], [9438, 9454, 1], [9439, 9454, 1], [9440, 9454, 1], [9441, 9454, 1], [9442, 9454, 1], [9443, 9454, 1]] + ) + # fmt: on + return g + + +def test_munich_firebrigade_hq(): + assert isinstance(munich_firebrigade_centre(), Graph) + + +def sycamore(): + # fmt: off + d = { "4fa1538b-f157-4d12-ab7e-0d6dd4905e6c": {2: 1}, "5de15c0d-69e3-4374-810f-12867ae70c27": {}, "a9a6df58-e5ec-4d2a-9892-95b0810a25ee": {4: 1}, "19b9ff27-b3ce-444a-89f7-01c64b6b8524": {6: 1}, "c7df5d31-a64a-4af8-998a-12f7bc41a041": {8: 1}, "4f9f6ca5-5546-4890-95e4-131c46aeb74e": {10: 1}, "27b9a829-f635-4995-ace8-b75a39586305": {12: 1}, "0090e8c8-55c4-46f5-b968-da13711b4a90": {14: 1}, "7b30c921-026b-48b0-99aa-9afc9c384a00": {16: 1}, "28eb48d9-d0f7-44d8-b752-024bb140a6f9": {18: 1, 22: 1}, "ed8585d5-7d6e-4d3f-9059-5a66b37a8967": {20: 1}, "67f867e9-ef62-4e60-b798-839a61d12cb8": {23: 1}, "3bc931de-805b-4f85-9469-4b9bc6ff4f56": {25: 1}, "8a91d6d4-2c88-492b-89f9-ea0215c378e8": {27: 1}, "a22d96ba-7206-4956-a201-a91aa207ec0e": {29: 1, 31: 1}, "f5051351-3450-4151-ac73-cc3b26fe016e": {33: 1}, "876af6fd-fa86-40de-b82c-13dacc1696e9": {34: 1}, "5176a34d-9834-4dd6-8d23-614491f7600c": {36: 1}, "ffd86852-1220-457e-9798-8908c02d67e6": {38: 1, 40: 1}, "931783f4-da11-43f2-9157-4e129ce55616": {42: 1}, "621cce8b-9df7-476a-9d98-646ab249b68d": {43: 1}, "814413e5-279b-49a5-9064-30d53a3f1187": {45: 1}, "b1f70911-1899-4d73-8cd3-b1a6ce120f74": {47: 1, 49: 1}, "3be2b316-4eee-4861-b44d-c4ba9bec509d": {52: 1}, "7e9ed721-22a4-4a15-90a6-92e0e33ef1e3": {51: 1}, "a41be6a4-6fad-4c10-bca4-43c7a681f8ee": {54: 1}, "57eb3996-7461-419d-87b1-68a4ef39dcdd": {56: 1, 58: 1}, "c8feb0ef-4a20-4d0e-9507-532769e185e1": {61: 1}, "71c15711-788e-4c2f-a4ed-be6d1687f080": {60: 1}, "ce03ddae-4c46-4b3e-a244-5807e8be5530": {63: 1}, "bc68460d-2e03-450e-bac7-077954c43399": {65: 1, 68: 1}, "c65f3d0b-9602-44dd-9464-1992e173d2a2": {67: 1}, "e5479364-babd-4794-9d6e-e59a674dd135": {70: 1}, "e02beb96-2c16-448b-9155-dd8f3de33d67": {72: 1}, "315d503a-ab9e-4028-a5a5-fcccbcb8d86b": {74: 1, 76: 1}, "e61b3f7e-eba8-47ee-9526-59b745839adc": {79: 1}, "5fd40caf-2750-4be8-b46a-df50556e4fe8": {78: 1}, "980cf2a3-1c08-4713-8f01-314000cc71ef": {81: 1}, "c9302a14-504a-45bd-a789-33b60a51411f": {83: 1, 85: 1}, "3a418656-e2f8-4266-a5c6-c453fcbd8c85": {93: 1}, "1ac64aa7-29b7-4869-b4d1-b92182e252fd": {87: 1, 89: 1}, "6751b556-1c67-47c6-9756-90a8694049ac": {91: 1}, "336d5353-af17-4ab6-90b9-ca172ec14d0b": {92: 1}, "3464128c-0064-4658-8143-12219732f306": {95: 1}, "69449c8d-1832-48bc-a0cf-6badad24180c": {97: 1, 100: 1}, "43cc45ee-180f-4066-8ac8-0443e0e98137": {99: 1}, "e44f7d86-0266-4cb0-96f1-48f00b7a3fb4": {102: 1}, "95b351cb-5ca5-413e-9358-74a9a6386525": {104: 1}, "b868b9e3-b253-46f9-adbc-a6f9e8141025": {106: 1, 108: 1}, "1eb8acc5-ab08-40f8-b883-632d115adadb": {110: 1}, "30d1f968-f3d1-476e-83a5-7fe5153b598f": {111: 1}, "a49c7766-5fe5-4aca-9ad0-0e92097ab97b": {113: 1}, "dbcd7dee-d2a9-4038-a3f7-0cd08ae893a9": {115: 1, 117: 1}, "7157c588-0312-46e7-b331-ac9b58db143b": {119: 1, 121: 1}, "66e26a09-1c3a-4ff1-88c0-ce935f47ce25": {125: 1}, "a142149e-425e-40b4-9eb0-9093e70baf1c": {123: 1}, "b5be7d65-98cb-4b2d-9111-0aef93a056ef": {124: 1}, "2db9bf02-3763-4ca9-be72-1b73ce96b051": {127: 1}, "032fd06a-0317-40c1-ac3b-f4e7d6815150": {129: 1, 131: 1}, "a109dac7-685d-4181-8a49-73ea1404e394": {133: 1}, "b2aa8139-8add-43c4-b789-4cb4b9300815": {134: 1}, "3a946bef-8486-49a3-b286-2ac8e61cb83a": {136: 1}, "51727ff3-8b24-4176-b0e0-d1098035c192": {138: 1}, "f1f4498d-e4d7-4ff8-b02e-491bf4e3a755": {140: 1, 142: 1}, "80f9d592-d177-4ad2-89e1-7f75c7355a35": {146: 1, 150: 1}, "954191e8-345e-4826-beed-d531c6adf4e9": {144: 1, 148: 1}, "0fe961d1-5192-492c-aea9-254986c60198": {160: 1}, "2fb707c3-a286-4e17-b561-6ca578c3fe8d": {158: 1}, "c82c09e1-fb3c-46b3-a480-161c38baf003": {159: 1}, "de7c80e8-5c15-4980-8fd2-bef46f739898": {152: 1, 154: 1}, "fe6d7a60-f93b-48f5-be20-cfd34689ca0a": {157: 1}, "19f548ca-b248-497f-b6b1-0586a759c938": {156: 1}, "ec5b3353-9720-4071-964e-827ef3438021": {162: 1}, "e192f79b-9ae1-4984-972b-65b2f3c49acb": {164: 1, 166: 1}, "e6404573-a3dc-42f8-9fbf-57edce633c09": {170: 1, 172: 1}, "e94bf2a2-82cb-4af2-8de3-a22ab41e0db4": {168: 1, 174: 1}, "d1968a39-43a5-41fc-bb56-eb1dd7634d14": {181: 1}, "7bfe182b-c585-4d94-a8e9-bb0bb461c997": {180: 1}, "b9792657-321a-42b9-a455-3fd6dbd534d6": {184: 1}, "9f97c9db-6a94-4b31-99db-0375147746f1": {176: 1, 178: 1}, "70927067-9359-43c1-8643-e3ef79c7f0e8": {182: 1}, "266b7e28-47b3-4f4e-844d-87c6e2a177d3": {183: 1}, "27e4205a-67d9-42c4-9b16-01a566f562fd": {186: 1}, "ad276853-9cea-4eb0-aeef-886d6dff1dc8": {188: 1}, "44b270e2-aae2-451a-aa10-6df901d768ce": {190: 1, 192: 1}, "626f5fbe-5ef3-4ccf-8346-40b809edfc77": {194: 1}, "b67a2b5f-3811-4d32-9f5f-9ff4a81543f0": {195: 1}, "57dcc509-97ac-4002-88ba-fb6f8ad32160": {197: 1}, "6313b73b-8a48-4a53-8557-6368408f0eac": {199: 1, 201: 1}, "8ce9fc88-b6ea-4959-93ec-cd8e3a589d89": {205: 1, 207: 1}, "055c0ef5-776a-4994-abcd-a51aed2a11cd": {203: 1, 209: 1}, "1ce46b4f-5c35-4720-a88f-42c177bfb36f": {211: 1, 213: 1}, "d90378e4-f533-4daf-a211-446d6867dc3f": {219: 1}, "397a88e6-f84b-4bd8-882b-b7f0dbf55d12": {215: 1}, "4ac51a6e-2d84-428f-8e0d-e8d70e81069e": {218: 1}, "7fd0fe61-6ef7-4d7d-add5-8e259ff9818a": {217: 1}, "27299cc2-6fdb-46dd-abc3-d38bef8eb562": {216: 1}, "1930b912-5cb3-4caa-bfce-8b9e8fc65371": {221: 1}, "76364142-f9e1-446f-b57c-4868196afa85": {223: 1}, "4371dc9f-291b-49c6-8da2-77740d446522": {225: 1, 227: 1}, "15bcbcf8-e567-4465-a7da-0d474b0f2583": {231: 1}, "ce71b245-5395-4356-b697-09d776e8e0fe": {229: 1}, "5311fe63-7538-4cfb-8dfa-d38f5c2edfa8": {232: 1}, "5dc74355-20cd-422b-a7a5-eceace4c1be9": {234: 1}, "59a6f4d2-4a52-478b-b4be-c4e75ac7971c": {236: 1, 238: 1}, "7b6ed155-4a76-4bf7-b4a1-4e64168f65ea": {258: 1}, "96cb120a-f7d5-4754-8623-cc7c221f876d": {240: 1}, "cc301427-2bfe-4eb8-8c81-1cda94691e85": {242: 1, 244: 1}, "e861e514-ff13-4a7b-af54-f6d5d0f4b7b2": {246: 1}, "9d6890c4-993a-4492-a1bd-2a961f7bb90f": {248: 1, 250: 1}, "12ca9678-3582-4116-aabb-28b4d60063cc": {254: 1}, "355ae401-c5e7-402c-994b-18f76f469954": {252: 1}, "1f12a52a-2dc0-45eb-b2f3-c31640b512e7": {253: 1}, "e488a1cf-c5d1-4684-abab-a1270980d73a": {256: 1}, "24721379-4cb1-40bb-8a0c-c528e846baa4": {259: 1}, "3f12cc19-70d0-4aa1-b200-0490c9004c90": {261: 1}, "d4ec293f-b4fe-4cc9-891b-eaa04f12f708": {263: 1, 265: 1}, "9d714ec4-6492-40e3-8201-0f1809b2e245": {286: 1}, "eb45c9f8-132c-4d23-8e9e-2c61b9903298": {267: 1}, "a934e012-ca86-4ce1-9074-97eeb013ea28": {269: 1, 271: 1}, "abeb9211-01f0-4f97-b48e-2fdb8b035a98": {275: 1, 277: 1}, "c590e314-e249-413a-ab1b-35e07705395d": {273: 1}, "6926f5fd-cf0a-4460-840d-a47f178571aa": {279: 1}, "bcdfbbed-1e16-49b9-af45-00f3ab6bb805": {281: 1}, "3a6bd40e-f1cd-4b38-a1f0-22e9165dbadc": {280: 1}, "a2adf679-c2b0-476c-8ef0-a2c2cd5b0c59": {283: 1}, "b084f142-f4ee-4150-8138-9118dd37f922": {285: 1}, "7a439598-e508-4cae-9d3c-16e88adb4cf5": {288: 1}, "2ec3e42d-e085-4a9b-9f74-8be8d03cc6cb": {290: 1, 292: 1}, "075f9a87-d8cd-4d79-a320-4b8a4f2c74da": {297: 1}, "81e27d1d-82bd-4ea9-8552-edb5b2d8742f": {294: 1}, "2cca5f43-5687-4c9b-ae38-50f47ef0e06e": {296: 1}, "671c1390-2a06-4f25-af8b-f606c742f444": {299: 1}, "80d305fe-156b-45ac-9f2f-09fd4456e1dd": {301: 1, 303: 1}, "a51f562d-f4a5-4d2a-9aac-d526e81f606e": {324: 1}, "d08ad686-0582-48b0-93e6-d00f1b1deef9": {305: 1}, "388cbfbc-8e8a-4148-ba3f-a0410aed31b2": {307: 1, 309: 1}, "ebe4a840-26a8-4fc5-8d1f-a566290eef7a": {313: 1}, "273f0260-d462-42b4-a8ba-66398b627191": {311: 1, 315: 1}, "fb7c51ac-6de3-4360-961e-2522edc0ec23": {318: 1}, "35fdc999-c528-4eea-8be4-bcad74a8178f": {317: 1}, "4e7d2456-c952-4108-8ce3-fa496d092f55": {319: 1}, "a19d54df-ef5f-4752-a93e-ebd2249b1a7d": {321: 1}, "d2c00d35-ee59-4938-8350-d2c33f0be99b": {323: 1}, "fe088f64-8f3e-4f25-a90a-81df75c34277": {326: 1}, "1c7e50fa-bb4b-45c1-80cc-72c51ca4c656": {328: 1, 330: 1}, "82f2e760-a8cc-4e3a-97be-de7901bfc25f": {332: 1}, "a3e94ce3-91a4-4bda-918c-8f2c8aec3fcb": {350: 1}, "a98fb5c2-1f73-4eb0-82e1-5c2eaf8981c7": {334: 1, 336: 1}, "2b9cc29f-dc41-4b65-891d-89b8b9d31014": {342: 1}, "ceda5351-12db-41d8-9520-1163d89b9bab": {338: 1, 340: 1}, "c4044057-ddc5-4db8-8406-604e0452e84e": {344: 1}, "90e9da7f-db2f-46d1-bf83-b891b1b1558d": {345: 1}, "f1d643f2-0dd6-44ba-87fa-a45c6d5f789f": {346: 1}, "ec49d772-8b68-44ef-86d2-8f60e10a446a": {348: 1}, "e608c330-3cf6-4366-9695-1d08706babbe": {351: 1}, "ebca9a33-7404-49ca-bfbe-f36f6f87c3df": {353: 1}, "98f7e431-7882-4e41-8eba-17b5fb74fef8": {355: 1, 357: 1}, "0af8f0f0-1338-474f-87c5-ef6b4528f1c0": {360: 1}, "03d317b7-ee5d-422d-94b2-df02bcc8c888": {359: 1}, "c13172cb-a1c8-4b5a-8acb-00312ef90bc4": {362: 1}, "6368ebc8-46a0-4318-937b-3ffec6b32685": {364: 1, 366: 1}, "975f3cc8-c3db-44e7-a26f-03a4bed58683": {371: 1}, "8842e96a-a5af-4b25-88f4-9cea6e70d022": {368: 1}, "b056e721-de72-4174-8a15-d5045efa27ae": {370: 1}, "b01bb019-853e-4931-830f-6ed1b11a0a59": {373: 1}, "dee8a02a-96af-4126-9193-6ea02b1182e2": {375: 1, 377: 1}, "43277e47-2478-49bd-b171-4893007cf7a6": {398: 1}, "777418b9-dcc3-4ca6-b230-083398c7174d": {379: 1}, "e5108eec-c148-4494-a16f-bb932483f245": {381: 1, 383: 1}, "ef8d1651-bcd6-4504-86ed-0306691193fb": {387: 1, 389: 1}, "2ec610d3-167c-4e76-95f9-0634f94aa003": {385: 1}, "ec1dc89b-9eb6-4be7-bf9b-9508003b3291": {391: 1}, "fa3ec3a8-2e51-4658-8be2-3353ccab1e9e": {393: 1}, "e338b1b0-54a1-4aa0-8d02-be36b0fd5efe": {392: 1}, "6309abdc-4731-4992-9cc2-ebe9d845bd72": {395: 1}, "79180493-4681-4717-b848-364cf76f7bb2": {397: 1}, "0b19db7c-9072-4308-9857-a560fff36546": {400: 1}, "12c98be6-3fbb-44f3-b235-a0687290b784": {402: 1, 404: 1}, "be4d15bf-8bd8-497d-b154-b055bcdc8809": {406: 1}, "edfa9633-aef5-4d6c-8c09-5b9ad27d246f": {408: 1}, "bb0a693a-c73e-4832-be4f-579414b5a3a1": {409: 1}, "b7b60058-622e-4e49-a1d6-6740992e9b35": {411: 1}, "35316d9d-ac85-4328-a3ae-01c72f8d30e2": {413: 1, 415: 1}, "091c0bcd-05cc-43e7-9774-e9831471c15f": {435: 1}, "31040008-57d5-457b-a699-0f245fd44614": {417: 1}, "51d402e4-97c2-485e-84db-4e3653649396": {419: 1, 421: 1}, "80c90cc6-a7e9-4888-8f46-922477f7a9d6": {423: 1, 427: 1}, "ec6799fb-9211-4050-b471-7effe90c6889": {425: 1}, "b76342a4-017f-471b-b002-d01506cba4e0": {430: 1}, "f31198c0-46d6-4067-bd06-eec8682b931a": {431: 1}, "925b96e3-27a6-44aa-9a60-817f92846d28": {429: 1}, "255dbe5d-57e5-4469-87e0-1ce05d3e84dd": {433: 1}, "44430be1-c2bc-420a-8127-c3602cd41b9a": {436: 1}, "04e068d3-560e-42e8-877c-ea8df93551cd": {438: 1}, "af7488f3-58bb-430a-bc42-5803cde0607a": {440: 1, 442: 1}, "a69be48e-38fb-43c4-bd82-2fa95834637e": {445: 1}, "87c46403-e497-483f-9468-964a3355d5ff": {444: 1}, "fe29cace-c889-4784-895f-ab9221ee5c9b": {447: 1}, "9d894af8-333b-47c4-a2cb-84de1455a055": {449: 1, 451: 1}, "df9195cb-6835-4fce-9c50-19486a8430ad": {453: 1}, "a82b7b4a-148c-497c-a7dc-c9f6b0116668": {454: 1}, "5ea7de11-0ea5-4c43-82d8-aaf75dff6e02": {456: 1}, "841f8fc9-ad01-4ee7-a711-3304b43e9204": {458: 1, 460: 1}, "c6c064c9-9d7e-491d-bc9f-091f53460ddd": {462: 1}, "a12b5acc-0fed-4d7f-b51a-18ab556a5253": {463: 1}, "d9d50b4c-b1e3-48be-8baf-90ac9830767c": {465: 1}, "b5309aab-bea7-4f02-b585-5199e7a74675": {467: 1, 469: 1}, "96e5a43b-d3fb-458f-93c5-4d6596add9d8": {471: 1}, "a1218323-3755-44b3-b9c2-aedd17c0ff4c": {472: 1}, "41b689c2-b92b-4faf-95ec-fd847cc8ae3d": {474: 1}, "1bdd29d6-2269-4427-bc0b-eebaf312d6f1": {476: 1}, "d367ad07-9a2f-45d6-87ef-8ba6d5eb8eac": {478: 1, 480: 1}, "3cb39c96-bd04-469a-9b43-207f148adcb2": {482: 1, 484: 1}, "2a38429c-1177-46d3-92a5-26ffe1b566ce": {499: 1}, "0ed4efa6-3244-4117-935f-ba1e2a30c66b": {498: 1}, "a4f59437-fba0-4af0-ad62-832c4ed01f2b": {486: 1, 488: 1}, "2a49ba21-a656-4d3c-8554-ad85b589ecea": {490: 1}, "764e783a-b4c0-4113-8aef-220fa535b08a": {491: 1}, "0b09e513-f6b5-490b-a02a-5395ec64a170": {493: 1}, "070a6139-b5fa-4dbf-a577-e2cc2b1da431": {495: 1}, "826ab194-81e4-4589-af2d-97a4540d8a52": {497: 1}, "f20b7c2e-a9a3-40ea-a38e-c6ffb0e30b28": {501: 1}, "2b1f9183-bff3-4144-9d97-df83e7965848": {503: 1}, "3f028373-f7a2-4bbb-b18b-e3a3f975741c": {505: 1, 507: 1}, "5d2eaf38-ab8e-4d8a-bb1f-ce54f86ba58d": {509: 1, 511: 1}, "5f93fe77-b2dc-43f0-af3a-c0c45e188dbb": {525: 1}, "27280661-3605-4d84-a606-154c9839580c": {524: 1}, "d2c1144c-f6e0-4f7e-8ee3-7eb8e8e0e99b": {513: 1, 515: 1}, "5e7bbb9e-2e10-4a60-ba88-116784de388d": {517: 1}, "c3ee336d-7307-4d2a-ba18-61fe0cb7b207": {518: 1}, "3b812e8d-ee52-49c7-a262-d3256d2ab9ed": {520: 1}, "c68d41f0-2813-4de2-9d4c-f47e718575bb": {522: 1}, "17b4d894-e888-45ee-94cf-f8f1e420bdbf": {526: 1}, "cd17ee9f-7e51-4646-ac7e-52c0a116d919": {528: 1}, "5d19bd69-cc2f-4257-8348-778454674f65": {531: 1}, "f1b7e72d-4664-4611-bef7-4f1bd45756d8": {}, "091b2905-4b05-4d1c-bd1d-ed607efa6b9a": {533: 1, 535: 1}, "ed57c144-3109-48c3-a011-d052eebca05f": {541: 1}, "e939595d-af2b-43a1-8f8a-9dd0010ebb05": {537: 1, 539: 1}, "91b57d6a-7673-4ac7-8d5f-b4265560b6bb": {556: 1}, "0027975d-7eff-4bbc-9317-6359874f6297": {543: 1, 545: 1}, "adcb1030-77be-4674-b7ee-da4f6bb39238": {554: 1}, "32cfbd94-3e45-4db4-833c-dae66f0612f4": {547: 1}, "ad174df9-aa81-49ec-8b9c-968fc4f07a47": {548: 1}, "d15f8b16-45da-442b-b3ba-3de66a9e4042": {550: 1}, "49f04698-3c88-412f-a089-e774103e4931": {552: 1}, "1d7d6aed-6a97-4ad5-ac02-930b2c64dc3d": {555: 1}, "ef181dda-6f15-4bfb-b3d8-1aa2681e9477": {558: 1}, "eaa655a6-35a7-495a-b543-69d3e300dcfb": {}, "458405f4-18a4-4394-ae7e-9cc4f8bb1d42": {561: 1}, "9a79505b-a232-45bf-8a13-3db4919540bb": {563: 1, 565: 1}, "55db2f55-7133-41c8-8f1e-ab47c82cbeda": {567: 1, 569: 1}, "96084128-7a2b-4ba0-9d8c-26c4b2435e13": {571: 1}, "741ac4f6-fdb6-434a-b1bb-c0269fba9a7e": {573: 1, 575: 1}, "1a869ce1-b753-4712-8d71-dd6b7cddc423": {586: 1}, "8a7b309e-5714-4a12-8dfd-243dee51d17c": {585: 1}, "5755027a-cb64-4877-a6df-5a938a136f11": {578: 1}, "45843e8f-b2ee-4ee6-b7e9-6870229cd374": {577: 1}, "1794ae8a-7bc3-4695-a494-c73205c1080b": {580: 1}, "ece89c5c-158d-47a6-8561-610d74938c0c": {582: 1}, "01388e93-86b6-4586-90e0-1c79322c7cc1": {584: 1}, "9bf1528c-824b-438d-932d-8d2dada8fd50": {588: 1}, "7d66ad60-031a-402e-a7f8-1df120cce5c2": {590: 1, 593: 1}, "36459016-a15c-40a7-9254-91ede6ad37e7": {592: 1}, "7359ee75-84b8-4d58-aaa1-e55cdf40ed7f": {595: 1}, "451641b0-cc93-4123-81bd-a593fa247ea2": {597: 1, 599: 1}, "dc7fdbcb-72b3-4234-87e8-05d11d23361f": {600: 1}, "8d965027-56b0-4b5b-bb38-05f2f2a3aa04": {602: 1}, "944c3092-59b2-4200-a5ba-95532552d586": {604: 1, 606: 1}, "aeb45d19-df6e-4aaa-a167-74593165f148": {607: 1}, "9dbae020-55fd-4511-bb9f-23f0336e98b5": {609: 1}, "fe42900d-e6fc-4c74-bf92-ecf398298382": {611: 1, 613: 1}, "c315e557-0b4d-4007-8061-188b7add29cb": {614: 1}, "a1c7d287-6ef2-495d-97d0-8e72a2165969": {616: 1}, "f94b659f-8101-4724-997f-4e4acb67b633": {618: 1}, "1a3c21a3-1ee7-49d7-82a0-53bf32562166": {620: 1, 622: 1}, "e1e8456f-8b2e-4c78-a786-e4578997baaa": {624: 1, 626: 1}, "0554f77f-db14-4d2d-ab99-922b0a7c024d": {719: 1}, "0dc2b623-ec68-4fc8-80f3-87d8211915f8": {668: 1}, "0e6bb5aa-6fa7-4ef3-a64a-14be7f8be1c1": {628: 1, 630: 1}, "80a07ddf-cb7d-4124-adbc-84e9b4a8ed37": {648: 1}, "8990b23c-c166-4ae1-9e00-167683bdb6df": {632: 1, 634: 1}, "dee8c4a6-0fca-4087-8565-7ac67a7372f7": {647: 1}, "6d2eeea2-39d7-480e-8bd4-35599cf5fb17": {636: 1, 638: 1}, "49b3ffc8-5be7-4962-b782-c1f7bebea37c": {640: 1, 642: 1}, "47874393-18d6-48e9-8090-f5160ea460bb": {646: 1}, "1c154be0-8314-497c-b2c7-ee09a6f7b47c": {645: 1}, "ce36a590-d9d7-4921-b4ee-ae271fcbd579": {644: 1}, "f2b8e1c3-05ce-43f2-82ee-44121803d3dc": {650: 1}, "15bf5661-0bec-48d8-bb0f-83e551e1e0a9": {652: 1, 654: 1}, "b2ae7ffe-8565-4f0a-bc6a-d79924f4b130": {667: 1}, "3e391d20-e4a9-4db1-a10e-a9c16101c883": {656: 1, 658: 1}, "eb8b786a-6d0e-44cd-a0fb-2b66c5ba94b2": {660: 1, 662: 1}, "191cf3a0-86b1-4fa2-b410-b5bf350c5045": {666: 1}, "91e10c8d-110b-4c81-be81-d34f63d4f75a": {664: 1}, "5b9c81cc-ff5a-4ba3-afb9-ac02c12f8b52": {665: 1}, "5dcf1a64-ae14-444a-9c25-3c0a9a9806d9": {670: 1}, "c7fae59c-ebf1-4ccd-bfc5-2ed48da49834": {672: 1, 674: 1}, "b39da577-f07c-48db-b6ee-10afecde4d7a": {676: 1, 678: 1}, "a9fb7fc7-549f-414c-af5b-7842998e8b2e": {716: 1}, "e4c2277d-9448-4dcb-a7f9-da060ee0516a": {680: 1, 682: 1}, "3db0efe1-95e8-4951-b884-f77d63e68d00": {692: 1}, "bc239422-7b45-44e4-b00f-398f75a2a52f": {684: 1, 686: 1}, "2f6f3214-3b99-4b82-b565-92b481f56a65": {696: 1}, "85e3c342-0d86-40f8-9619-badd267879c3": {695: 1}, "04f4f557-29c0-416e-9c2e-c20d5631574b": {688: 1, 690: 1}, "73359fb0-aead-4daf-93e8-9f284aefb32f": {694: 1}, "cf4aa89c-b905-4e13-adba-c0e065022571": {693: 1}, "4213325b-b1f3-4a87-9f61-4e1812f806f5": {698: 1}, "45aaa1d9-f759-412d-93ac-c645bc08b4b5": {700: 1, 702: 1}, "93c39415-a801-46f6-b734-3004ff610e25": {704: 1, 706: 1}, "1e2bae11-f1c8-4654-9f99-92f6788750d7": {715: 1}, "271f872d-6071-462b-8cae-c1c413eabd23": {708: 1, 710: 1}, "cf8f75f2-c4ca-4228-a210-2a540c899647": {714: 1}, "49f3ac6e-dc6e-4962-8a78-b98f25fbcd0e": {713: 1}, "15866fa7-ad28-4bda-9fd7-abda612b4095": {712: 1}, "43daa433-514a-4812-af5b-e7e23eafc4bd": {718: 1}, "f296c74b-6640-4415-a98a-5c65e9b2cf25": {721: 1}, "20ab2153-21c1-4e47-ada9-4ab1ec51fc3d": {723: 1, 725: 1}, "01cf6426-c744-4461-ba2e-3ff44f347a03": {727: 1, 729: 1}, "4a654c26-4b50-45bf-a069-5062b494a7d5": {733: 1}, "23dd93f3-0c8f-4121-9597-8e96645bcf3e": {731: 1}, "0ae33ccd-5165-4886-b0b4-bbeddd38814b": {732: 1}, "f0a86225-83f9-4ae2-81f7-6a44d41482dc": {735: 1}, "c1aa91c7-985a-4d0f-9ee9-463d9ca426d3": {737: 1, 739: 1}, "cc8f1a34-d150-45fa-aced-01853a757b1e": {741: 1, 743: 1}, "2b4f1a40-b56b-4848-bf82-fd9d5a8b57c2": {747: 1}, + "cbe422c7-00c5-446b-ba62-ca33190c5653": {745: 1},"06850c10-caf2-4061-a064-0b16186a2c17": {746: 1},"28c5a495-d3a7-44d8-9170-0afa12275f09": {749: 1},"1712265e-da7a-47f6-8f61-f6bd8f331237": {}, + "2eedf055-b7eb-426f-9d88-f1fbe0d3cdf7": {752: 1},"140be349-6873-46cd-a802-615775607e00": {}, + 2: {1: 1},1: {"a9a6df58-e5ec-4d2a-9892-95b0810a25ee": 1}, + 4: {3: 1},3: {"19b9ff27-b3ce-444a-89f7-01c64b6b8524": 1}, + 6: {5: 1}, 5: {"c7df5d31-a64a-4af8-998a-12f7bc41a041": 1}, 8: {7: 1}, 7: {"4f9f6ca5-5546-4890-95e4-131c46aeb74e": 1}, 10: {9: 1}, 9: {"27b9a829-f635-4995-ace8-b75a39586305": 1}, 12: {11: 1}, 11: {"0090e8c8-55c4-46f5-b968-da13711b4a90": 1}, 14: {13: 1}, 13: {"7b30c921-026b-48b0-99aa-9afc9c384a00": 1}, 16: {15: 1}, 15: {"28eb48d9-d0f7-44d8-b752-024bb140a6f9": 1}, 18: {17: 1}, 17: {"ed8585d5-7d6e-4d3f-9059-5a66b37a8967": 1}, 20: {19: 1}, 19: {"67f867e9-ef62-4e60-b798-839a61d12cb8": 1}, 22: {21: 1}, 21: {"3bc931de-805b-4f85-9469-4b9bc6ff4f56": 1}, 23: {21: 1}, 25: {24: 1}, 24: {"8a91d6d4-2c88-492b-89f9-ea0215c378e8": 1}, 27: {26: 1}, 26: {"a22d96ba-7206-4956-a201-a91aa207ec0e": 1}, 29: {28: 1}, 28: {"f5051351-3450-4151-ac73-cc3b26fe016e": 1}, 31: {30: 1}, 30: {"876af6fd-fa86-40de-b82c-13dacc1696e9": 1}, 33: {32: 1}, 32: {"5176a34d-9834-4dd6-8d23-614491f7600c": 1}, 34: {32: 1}, 36: {35: 1}, 35: {"ffd86852-1220-457e-9798-8908c02d67e6": 1}, 38: {37: 1}, 37: {"931783f4-da11-43f2-9157-4e129ce55616": 1}, 40: {39: 1}, 39: {"621cce8b-9df7-476a-9d98-646ab249b68d": 1}, 42: {41: 1}, 41: {"814413e5-279b-49a5-9064-30d53a3f1187": 1}, 43: {41: 1}, 45: {44: 1}, 44: {"b1f70911-1899-4d73-8cd3-b1a6ce120f74": 1}, 47: {46: 1}, 46: {"3be2b316-4eee-4861-b44d-c4ba9bec509d": 1}, 49: {48: 1}, 48: {"7e9ed721-22a4-4a15-90a6-92e0e33ef1e3": 1}, 51: {50: 1}, 50: {"a41be6a4-6fad-4c10-bca4-43c7a681f8ee": 1}, 52: {50: 1}, 54: {53: 1}, 53: {"57eb3996-7461-419d-87b1-68a4ef39dcdd": 1}, 56: {55: 1}, 55: {"c8feb0ef-4a20-4d0e-9507-532769e185e1": 1}, 58: {57: 1}, 57: {"71c15711-788e-4c2f-a4ed-be6d1687f080": 1}, 60: {59: 1}, 59: {"ce03ddae-4c46-4b3e-a244-5807e8be5530": 1}, 61: {59: 1}, 63: {62: 1}, 62: {"bc68460d-2e03-450e-bac7-077954c43399": 1}, 65: {64: 1}, 64: {"c65f3d0b-9602-44dd-9464-1992e173d2a2": 1}, 67: {66: 1}, 66: {"e5479364-babd-4794-9d6e-e59a674dd135": 1}, 68: {66: 1}, 70: {69: 1}, 69: {"e02beb96-2c16-448b-9155-dd8f3de33d67": 1}, 72: {71: 1}, 71: {"315d503a-ab9e-4028-a5a5-fcccbcb8d86b": 1}, 74: {73: 1}, 73: {"e61b3f7e-eba8-47ee-9526-59b745839adc": 1}, 76: {75: 1}, 75: {"5fd40caf-2750-4be8-b46a-df50556e4fe8": 1}, 78: {77: 1}, 77: {"980cf2a3-1c08-4713-8f01-314000cc71ef": 1}, 79: {77: 1}, 81: {80: 1}, 80: {"c9302a14-504a-45bd-a789-33b60a51411f": 1}, 83: {82: 1}, 82: {"3a418656-e2f8-4266-a5c6-c453fcbd8c85": 1}, 85: {84: 1}, 84: {"1ac64aa7-29b7-4869-b4d1-b92182e252fd": 1}, 87: {86: 1}, 86: {"6751b556-1c67-47c6-9756-90a8694049ac": 1}, 89: {88: 1}, 88: {"336d5353-af17-4ab6-90b9-ca172ec14d0b": 1}, 91: {90: 1}, 90: {"3464128c-0064-4658-8143-12219732f306": 1}, 92: {90: 1}, 93: {90: 1}, 95: {94: 1}, 94: {"69449c8d-1832-48bc-a0cf-6badad24180c": 1}, 97: {96: 1}, 96: {"43cc45ee-180f-4066-8ac8-0443e0e98137": 1}, 99: {98: 1}, 98: {"e44f7d86-0266-4cb0-96f1-48f00b7a3fb4": 1}, 100: {98: 1}, 102: {101: 1}, 101: {"95b351cb-5ca5-413e-9358-74a9a6386525": 1}, 104: {103: 1}, 103: {"b868b9e3-b253-46f9-adbc-a6f9e8141025": 1}, 106: {105: 1}, 105: {"1eb8acc5-ab08-40f8-b883-632d115adadb": 1}, 108: {107: 1}, 107: {"30d1f968-f3d1-476e-83a5-7fe5153b598f": 1}, 110: {109: 1}, 109: {"a49c7766-5fe5-4aca-9ad0-0e92097ab97b": 1}, 111: {109: 1}, 113: {112: 1}, 112: {"dbcd7dee-d2a9-4038-a3f7-0cd08ae893a9": 1}, 115: {114: 1}, 114: {"7157c588-0312-46e7-b331-ac9b58db143b": 1}, 117: {116: 1}, 116: {"66e26a09-1c3a-4ff1-88c0-ce935f47ce25": 1}, 119: {118: 1}, 118: {"a142149e-425e-40b4-9eb0-9093e70baf1c": 1}, 121: {120: 1}, 120: {"b5be7d65-98cb-4b2d-9111-0aef93a056ef": 1}, 123: {122: 1}, 122: {"2db9bf02-3763-4ca9-be72-1b73ce96b051": 1}, 124: {122: 1}, 125: {122: 1}, 127: {126: 1}, 126: {"032fd06a-0317-40c1-ac3b-f4e7d6815150": 1}, 129: {128: 1}, 128: {"a109dac7-685d-4181-8a49-73ea1404e394": 1}, 131: {130: 1}, 130: {"b2aa8139-8add-43c4-b789-4cb4b9300815": 1}, 133: {132: 1}, 132: {"3a946bef-8486-49a3-b286-2ac8e61cb83a": 1}, 134: {132: 1}, 136: {135: 1}, 135: {"51727ff3-8b24-4176-b0e0-d1098035c192": 1}, 138: {137: 1}, 137: {"f1f4498d-e4d7-4ff8-b02e-491bf4e3a755": 1}, 140: {139: 1}, 139: {"80f9d592-d177-4ad2-89e1-7f75c7355a35": 1}, 142: {141: 1}, 141: {"954191e8-345e-4826-beed-d531c6adf4e9": 1}, 144: {143: 1}, 143: {"0fe961d1-5192-492c-aea9-254986c60198": 1}, 146: {145: 1}, 145: {"2fb707c3-a286-4e17-b561-6ca578c3fe8d": 1}, 148: {147: 1}, 147: {"c82c09e1-fb3c-46b3-a480-161c38baf003": 1}, 150: {149: 1}, 149: {"de7c80e8-5c15-4980-8fd2-bef46f739898": 1}, 152: {151: 1}, 151: {"fe6d7a60-f93b-48f5-be20-cfd34689ca0a": 1}, 154: {153: 1}, 153: {"19f548ca-b248-497f-b6b1-0586a759c938": 1}, 156: {155: 1}, 155: {"ec5b3353-9720-4071-964e-827ef3438021": 1}, 157: {155: 1}, 158: {155: 1}, 159: {155: 1}, 160: {155: 1}, 162: {161: 1}, 161: {"e192f79b-9ae1-4984-972b-65b2f3c49acb": 1}, 164: {163: 1}, 163: {"e6404573-a3dc-42f8-9fbf-57edce633c09": 1}, 166: {165: 1}, 165: {"e94bf2a2-82cb-4af2-8de3-a22ab41e0db4": 1}, 168: {167: 1}, 167: {"d1968a39-43a5-41fc-bb56-eb1dd7634d14": 1}, 170: {169: 1}, 169: {"7bfe182b-c585-4d94-a8e9-bb0bb461c997": 1}, 172: {171: 1}, 171: {"b9792657-321a-42b9-a455-3fd6dbd534d6": 1}, 174: {173: 1}, 173: {"9f97c9db-6a94-4b31-99db-0375147746f1": 1}, 176: {175: 1}, 175: {"70927067-9359-43c1-8643-e3ef79c7f0e8": 1}, 178: {177: 1}, 177: {"266b7e28-47b3-4f4e-844d-87c6e2a177d3": 1}, 180: {179: 1}, 179: {"27e4205a-67d9-42c4-9b16-01a566f562fd": 1}, 181: {179: 1}, 182: {179: 1}, 183: {179: 1}, 184: {179: 1}, 186: {185: 1}, 185: {"ad276853-9cea-4eb0-aeef-886d6dff1dc8": 1}, 188: {187: 1}, 187: {"44b270e2-aae2-451a-aa10-6df901d768ce": 1}, 190: {189: 1}, 189: {"626f5fbe-5ef3-4ccf-8346-40b809edfc77": 1}, 192: {191: 1}, 191: {"b67a2b5f-3811-4d32-9f5f-9ff4a81543f0": 1}, 194: {193: 1}, 193: {"57dcc509-97ac-4002-88ba-fb6f8ad32160": 1}, 195: {193: 1}, 197: {196: 1}, 196: {"6313b73b-8a48-4a53-8557-6368408f0eac": 1}, 199: {198: 1}, 198: {"8ce9fc88-b6ea-4959-93ec-cd8e3a589d89": 1}, 201: {200: 1}, 200: {"055c0ef5-776a-4994-abcd-a51aed2a11cd": 1}, 203: {202: 1}, 202: {"1ce46b4f-5c35-4720-a88f-42c177bfb36f": 1}, 205: {204: 1}, 204: {"d90378e4-f533-4daf-a211-446d6867dc3f": 1}, 207: {206: 1}, 206: {"397a88e6-f84b-4bd8-882b-b7f0dbf55d12": 1}, 209: {208: 1}, 208: {"4ac51a6e-2d84-428f-8e0d-e8d70e81069e": 1}, 211: {210: 1}, 210: {"7fd0fe61-6ef7-4d7d-add5-8e259ff9818a": 1}, 213: {212: 1}, 212: {"27299cc2-6fdb-46dd-abc3-d38bef8eb562": 1}, 215: {214: 1}, 214: {"1930b912-5cb3-4caa-bfce-8b9e8fc65371": 1}, 216: {214: 1}, 217: {214: 1}, 218: {214: 1}, 219: {214: 1}, 221: {220: 1}, 220: {"76364142-f9e1-446f-b57c-4868196afa85": 1}, 223: {222: 1}, 222: {"4371dc9f-291b-49c6-8da2-77740d446522": 1}, 225: {224: 1}, 224: {"15bcbcf8-e567-4465-a7da-0d474b0f2583": 1}, 227: {226: 1}, 226: {"ce71b245-5395-4356-b697-09d776e8e0fe": 1}, 229: {228: 1}, 228: {"5311fe63-7538-4cfb-8dfa-d38f5c2edfa8": 1}, 231: {230: 1}, 230: {"5dc74355-20cd-422b-a7a5-eceace4c1be9": 1}, 232: {230: 1}, 234: {233: 1}, 233: {"59a6f4d2-4a52-478b-b4be-c4e75ac7971c": 1}, 236: {235: 1}, 235: {"7b6ed155-4a76-4bf7-b4a1-4e64168f65ea": 1}, 238: {237: 1}, 237: {"96cb120a-f7d5-4754-8623-cc7c221f876d": 1}, 240: {239: 1}, 239: {"cc301427-2bfe-4eb8-8c81-1cda94691e85": 1}, 242: {241: 1}, 241: {"e861e514-ff13-4a7b-af54-f6d5d0f4b7b2": 1}, 244: {243: 1}, 243: {"9d6890c4-993a-4492-a1bd-2a961f7bb90f": 1}, 246: {245: 1}, 245: {"12ca9678-3582-4116-aabb-28b4d60063cc": 1}, 248: {247: 1}, 247: {"355ae401-c5e7-402c-994b-18f76f469954": 1}, 250: {249: 1}, 249: {"1f12a52a-2dc0-45eb-b2f3-c31640b512e7": 1}, 252: {251: 1}, 251: {"e488a1cf-c5d1-4684-abab-a1270980d73a": 1}, 253: {251: 1}, 254: {251: 1}, 256: {255: 1}, 255: {"24721379-4cb1-40bb-8a0c-c528e846baa4": 1}, 258: {257: 1}, 257: {"3f12cc19-70d0-4aa1-b200-0490c9004c90": 1}, 259: {257: 1}, 261: {260: 1}, 260: {"d4ec293f-b4fe-4cc9-891b-eaa04f12f708": 1}, 263: {262: 1}, 262: {"9d714ec4-6492-40e3-8201-0f1809b2e245": 1}, 265: {264: 1}, 264: {"eb45c9f8-132c-4d23-8e9e-2c61b9903298": 1}, 267: {266: 1}, 266: {"a934e012-ca86-4ce1-9074-97eeb013ea28": 1}, 269: {268: 1}, 268: {"abeb9211-01f0-4f97-b48e-2fdb8b035a98": 1}, 271: {270: 1}, 270: {"c590e314-e249-413a-ab1b-35e07705395d": 1}, 273: {272: 1}, 272: {"6926f5fd-cf0a-4460-840d-a47f178571aa": 1}, 275: {274: 1}, 274: {"bcdfbbed-1e16-49b9-af45-00f3ab6bb805": 1}, 277: {276: 1}, 276: {"3a6bd40e-f1cd-4b38-a1f0-22e9165dbadc": 1}, 279: {278: 1}, 278: {"a2adf679-c2b0-476c-8ef0-a2c2cd5b0c59": 1}, 280: {278: 1}, 281: {278: 1}, 283: {282: 1}, 282: {"b084f142-f4ee-4150-8138-9118dd37f922": 1}, 285: {284: 1}, 284: {"7a439598-e508-4cae-9d3c-16e88adb4cf5": 1}, 286: {284: 1}, 288: {287: 1}, 287: {"2ec3e42d-e085-4a9b-9f74-8be8d03cc6cb": 1}, 290: {289: 1}, 289: {"075f9a87-d8cd-4d79-a320-4b8a4f2c74da": 1}, 292: {291: 1}, 291: {"81e27d1d-82bd-4ea9-8552-edb5b2d8742f": 1}, 294: {293: 1}, 293: {"2cca5f43-5687-4c9b-ae38-50f47ef0e06e": 1}, 296: {295: 1}, 295: {"671c1390-2a06-4f25-af8b-f606c742f444": 1}, 297: {295: 1}, 299: {298: 1}, 298: {"80d305fe-156b-45ac-9f2f-09fd4456e1dd": 1}, 301: {300: 1}, 300: {"a51f562d-f4a5-4d2a-9aac-d526e81f606e": 1}, 303: {302: 1}, 302: {"d08ad686-0582-48b0-93e6-d00f1b1deef9": 1}, 305: {304: 1}, 304: {"388cbfbc-8e8a-4148-ba3f-a0410aed31b2": 1}, 307: {306: 1}, 306: {"ebe4a840-26a8-4fc5-8d1f-a566290eef7a": 1}, 309: {308: 1}, 308: {"273f0260-d462-42b4-a8ba-66398b627191": 1}, 311: {310: 1}, 310: {"fb7c51ac-6de3-4360-961e-2522edc0ec23": 1}, 313: {312: 1}, 312: {"35fdc999-c528-4eea-8be4-bcad74a8178f": 1}, 315: {314: 1}, 314: {"4e7d2456-c952-4108-8ce3-fa496d092f55": 1}, 317: {316: 1}, 316: {"a19d54df-ef5f-4752-a93e-ebd2249b1a7d": 1}, 318: {316: 1}, 319: {316: 1}, 321: {320: 1}, 320: {"d2c00d35-ee59-4938-8350-d2c33f0be99b": 1}, 323: {322: 1}, 322: {"fe088f64-8f3e-4f25-a90a-81df75c34277": 1}, 324: {322: 1}, 326: {325: 1}, 325: {"1c7e50fa-bb4b-45c1-80cc-72c51ca4c656": 1}, 328: {327: 1}, 327: {"82f2e760-a8cc-4e3a-97be-de7901bfc25f": 1}, 330: {329: 1}, 329: {"a3e94ce3-91a4-4bda-918c-8f2c8aec3fcb": 1}, 332: {331: 1}, 331: {"a98fb5c2-1f73-4eb0-82e1-5c2eaf8981c7": 1}, 334: {333: 1}, 333: {"2b9cc29f-dc41-4b65-891d-89b8b9d31014": 1}, 336: {335: 1}, 335: {"ceda5351-12db-41d8-9520-1163d89b9bab": 1}, 338: {337: 1}, 337: {"c4044057-ddc5-4db8-8406-604e0452e84e": 1}, 340: {339: 1}, 339: {"90e9da7f-db2f-46d1-bf83-b891b1b1558d": 1}, 342: {341: 1}, 341: {"f1d643f2-0dd6-44ba-87fa-a45c6d5f789f": 1}, 344: {343: 1}, 343: {"ec49d772-8b68-44ef-86d2-8f60e10a446a": 1}, 345: {343: 1}, 346: {343: 1}, 348: {347: 1}, 347: {"e608c330-3cf6-4366-9695-1d08706babbe": 1}, 350: {349: 1}, 349: {"ebca9a33-7404-49ca-bfbe-f36f6f87c3df": 1}, 351: {349: 1}, 353: {352: 1}, 352: {"98f7e431-7882-4e41-8eba-17b5fb74fef8": 1}, 355: {354: 1}, 354: {"0af8f0f0-1338-474f-87c5-ef6b4528f1c0": 1}, 357: {356: 1}, 356: {"03d317b7-ee5d-422d-94b2-df02bcc8c888": 1}, 359: {358: 1}, 358: {"c13172cb-a1c8-4b5a-8acb-00312ef90bc4": 1}, 360: {358: 1}, 362: {361: 1}, 361: {"6368ebc8-46a0-4318-937b-3ffec6b32685": 1}, 364: {363: 1}, 363: {"975f3cc8-c3db-44e7-a26f-03a4bed58683": 1}, 366: {365: 1}, 365: {"8842e96a-a5af-4b25-88f4-9cea6e70d022": 1}, 368: {367: 1}, 367: {"b056e721-de72-4174-8a15-d5045efa27ae": 1}, 370: {369: 1}, 369: {"b01bb019-853e-4931-830f-6ed1b11a0a59": 1}, 371: {369: 1}, 373: {372: 1}, 372: {"dee8a02a-96af-4126-9193-6ea02b1182e2": 1}, 375: {374: 1}, 374: {"43277e47-2478-49bd-b171-4893007cf7a6": 1}, 377: {376: 1}, 376: {"777418b9-dcc3-4ca6-b230-083398c7174d": 1}, 379: {378: 1}, 378: {"e5108eec-c148-4494-a16f-bb932483f245": 1}, 381: {380: 1}, 380: {"ef8d1651-bcd6-4504-86ed-0306691193fb": 1}, 383: {382: 1}, 382: {"2ec610d3-167c-4e76-95f9-0634f94aa003": 1}, 385: {384: 1}, 384: {"ec1dc89b-9eb6-4be7-bf9b-9508003b3291": 1}, 387: {386: 1}, 386: {"fa3ec3a8-2e51-4658-8be2-3353ccab1e9e": 1}, 389: {388: 1}, 388: {"e338b1b0-54a1-4aa0-8d02-be36b0fd5efe": 1}, 391: {390: 1}, 390: {"6309abdc-4731-4992-9cc2-ebe9d845bd72": 1}, 392: {390: 1}, 393: {390: 1}, 395: {394: 1}, 394: {"79180493-4681-4717-b848-364cf76f7bb2": 1}, 397: {396: 1}, 396: {"0b19db7c-9072-4308-9857-a560fff36546": 1}, 398: {396: 1}, 400: {399: 1}, 399: {"12c98be6-3fbb-44f3-b235-a0687290b784": 1}, 402: {401: 1}, 401: {"be4d15bf-8bd8-497d-b154-b055bcdc8809": 1}, 404: {403: 1}, 403: {"edfa9633-aef5-4d6c-8c09-5b9ad27d246f": 1}, 406: {405: 1}, 405: {"bb0a693a-c73e-4832-be4f-579414b5a3a1": 1}, 408: {407: 1}, 407: {"b7b60058-622e-4e49-a1d6-6740992e9b35": 1}, 409: {407: 1}, 411: {410: 1}, 410: {"35316d9d-ac85-4328-a3ae-01c72f8d30e2": 1}, 413: {412: 1}, 412: {"091c0bcd-05cc-43e7-9774-e9831471c15f": 1}, 415: {414: 1}, 414: {"31040008-57d5-457b-a699-0f245fd44614": 1}, 417: {416: 1}, 416: {"51d402e4-97c2-485e-84db-4e3653649396": 1}, 419: {418: 1}, 418: {"80c90cc6-a7e9-4888-8f46-922477f7a9d6": 1}, 421: {420: 1}, 420: {"ec6799fb-9211-4050-b471-7effe90c6889": 1}, 423: {422: 1}, 422: {"b76342a4-017f-471b-b002-d01506cba4e0": 1}, 425: {424: 1}, 424: {"f31198c0-46d6-4067-bd06-eec8682b931a": 1}, 427: {426: 1}, 426: {"925b96e3-27a6-44aa-9a60-817f92846d28": 1}, 429: {428: 1}, 428: {"255dbe5d-57e5-4469-87e0-1ce05d3e84dd": 1}, 430: {428: 1}, 431: {428: 1}, 433: {432: 1}, 432: {"44430be1-c2bc-420a-8127-c3602cd41b9a": 1}, 435: {434: 1}, 434: {"04e068d3-560e-42e8-877c-ea8df93551cd": 1}, 436: {434: 1}, 438: {437: 1}, 437: {"af7488f3-58bb-430a-bc42-5803cde0607a": 1}, 440: {439: 1}, 439: {"a69be48e-38fb-43c4-bd82-2fa95834637e": 1}, 442: {441: 1}, 441: {"87c46403-e497-483f-9468-964a3355d5ff": 1}, 444: {443: 1}, 443: {"fe29cace-c889-4784-895f-ab9221ee5c9b": 1}, 445: {443: 1}, 447: {446: 1}, 446: {"9d894af8-333b-47c4-a2cb-84de1455a055": 1}, 449: {448: 1}, 448: {"df9195cb-6835-4fce-9c50-19486a8430ad": 1}, 451: {450: 1}, 450: {"a82b7b4a-148c-497c-a7dc-c9f6b0116668": 1}, 453: {452: 1}, 452: {"5ea7de11-0ea5-4c43-82d8-aaf75dff6e02": 1}, 454: {452: 1}, 456: {455: 1}, 455: {"841f8fc9-ad01-4ee7-a711-3304b43e9204": 1}, 458: {457: 1}, 457: {"c6c064c9-9d7e-491d-bc9f-091f53460ddd": 1}, 460: {459: 1}, 459: {"a12b5acc-0fed-4d7f-b51a-18ab556a5253": 1}, 462: {461: 1}, 461: {"d9d50b4c-b1e3-48be-8baf-90ac9830767c": 1}, 463: {461: 1}, 465: {464: 1}, 464: {"b5309aab-bea7-4f02-b585-5199e7a74675": 1}, 467: {466: 1}, 466: {"96e5a43b-d3fb-458f-93c5-4d6596add9d8": 1}, 469: {468: 1}, 468: {"a1218323-3755-44b3-b9c2-aedd17c0ff4c": 1}, 471: {470: 1}, 470: {"41b689c2-b92b-4faf-95ec-fd847cc8ae3d": 1}, 472: {470: 1}, 474: {473: 1}, 473: {"1bdd29d6-2269-4427-bc0b-eebaf312d6f1": 1}, 476: {475: 1}, 475: {"d367ad07-9a2f-45d6-87ef-8ba6d5eb8eac": 1}, 478: {477: 1}, 477: {"3cb39c96-bd04-469a-9b43-207f148adcb2": 1}, 480: {479: 1}, 479: {"2a38429c-1177-46d3-92a5-26ffe1b566ce": 1}, 482: {481: 1}, 481: {"0ed4efa6-3244-4117-935f-ba1e2a30c66b": 1}, 484: {483: 1}, 483: {"a4f59437-fba0-4af0-ad62-832c4ed01f2b": 1}, 486: {485: 1}, 485: {"2a49ba21-a656-4d3c-8554-ad85b589ecea": 1}, 488: {487: 1}, 487: {"764e783a-b4c0-4113-8aef-220fa535b08a": 1}, 490: {489: 1}, 489: {"0b09e513-f6b5-490b-a02a-5395ec64a170": 1}, 491: {489: 1}, 493: {492: 1}, 492: {"070a6139-b5fa-4dbf-a577-e2cc2b1da431": 1}, 495: {494: 1}, 494: {"826ab194-81e4-4589-af2d-97a4540d8a52": 1}, 497: {496: 1}, 496: {"f20b7c2e-a9a3-40ea-a38e-c6ffb0e30b28": 1}, 498: {496: 1}, 499: {496: 1}, 501: {500: 1}, 500: {"2b1f9183-bff3-4144-9d97-df83e7965848": 1}, 503: {502: 1}, 502: {"3f028373-f7a2-4bbb-b18b-e3a3f975741c": 1}, 505: {504: 1}, 504: {"5d2eaf38-ab8e-4d8a-bb1f-ce54f86ba58d": 1}, 507: {506: 1}, 506: {"5f93fe77-b2dc-43f0-af3a-c0c45e188dbb": 1}, 509: {508: 1}, 508: {"27280661-3605-4d84-a606-154c9839580c": 1}, 511: {510: 1}, 510: {"d2c1144c-f6e0-4f7e-8ee3-7eb8e8e0e99b": 1}, 513: {512: 1}, 512: {"5e7bbb9e-2e10-4a60-ba88-116784de388d": 1}, 515: {514: 1}, 514: {"c3ee336d-7307-4d2a-ba18-61fe0cb7b207": 1}, 517: {516: 1}, 516: {"3b812e8d-ee52-49c7-a262-d3256d2ab9ed": 1}, 518: {516: 1}, 520: {519: 1}, 519: {"c68d41f0-2813-4de2-9d4c-f47e718575bb": 1}, 522: {521: 1}, 521: {"17b4d894-e888-45ee-94cf-f8f1e420bdbf": 1}, 524: {523: 1}, 523: {"cd17ee9f-7e51-4646-ac7e-52c0a116d919": 1}, 525: {523: 1}, 526: {523: 1}, 528: {527: 1, 529: 1}, 527: {"5d19bd69-cc2f-4257-8348-778454674f65": 1}, 529: {"f1b7e72d-4664-4611-bef7-4f1bd45756d8": 1}, 531: {530: 1}, 530: {"091b2905-4b05-4d1c-bd1d-ed607efa6b9a": 1}, 533: {532: 1}, 532: {"ed57c144-3109-48c3-a011-d052eebca05f": 1}, 535: {534: 1}, 534: {"e939595d-af2b-43a1-8f8a-9dd0010ebb05": 1}, 537: {536: 1}, 536: {"91b57d6a-7673-4ac7-8d5f-b4265560b6bb": 1}, 539: {538: 1}, 538: {"0027975d-7eff-4bbc-9317-6359874f6297": 1}, 541: {540: 1}, 540: {"adcb1030-77be-4674-b7ee-da4f6bb39238": 1}, 543: {542: 1}, 542: {"32cfbd94-3e45-4db4-833c-dae66f0612f4": 1}, 545: {544: 1}, 544: {"ad174df9-aa81-49ec-8b9c-968fc4f07a47": 1}, 547: {546: 1}, 546: {"d15f8b16-45da-442b-b3ba-3de66a9e4042": 1}, 548: {546: 1}, 550: {549: 1}, 549: {"49f04698-3c88-412f-a089-e774103e4931": 1}, 552: {551: 1}, 551: {"1d7d6aed-6a97-4ad5-ac02-930b2c64dc3d": 1}, 554: {553: 1}, 553: {"ef181dda-6f15-4bfb-b3d8-1aa2681e9477": 1}, 555: {553: 1}, 556: {553: 1}, 558: {557: 1, 559: 1}, 557: {"eaa655a6-35a7-495a-b543-69d3e300dcfb": 1}, 559: {"458405f4-18a4-4394-ae7e-9cc4f8bb1d42": 1}, 561: {560: 1}, 560: {"9a79505b-a232-45bf-8a13-3db4919540bb": 1}, 563: {562: 1}, 562: {"55db2f55-7133-41c8-8f1e-ab47c82cbeda": 1}, 565: {564: 1}, 564: {"96084128-7a2b-4ba0-9d8c-26c4b2435e13": 1}, 567: {566: 1}, 566: {"741ac4f6-fdb6-434a-b1bb-c0269fba9a7e": 1}, 569: {568: 1}, 568: {"1a869ce1-b753-4712-8d71-dd6b7cddc423": 1}, 571: {570: 1}, 570: {"8a7b309e-5714-4a12-8dfd-243dee51d17c": 1}, 573: {572: 1}, 572: {"5755027a-cb64-4877-a6df-5a938a136f11": 1}, 575: {574: 1}, 574: {"45843e8f-b2ee-4ee6-b7e9-6870229cd374": 1}, 577: {576: 1}, 576: {"1794ae8a-7bc3-4695-a494-c73205c1080b": 1}, 578: {576: 1}, 580: {579: 1}, 579: {"ece89c5c-158d-47a6-8561-610d74938c0c": 1}, 582: {581: 1}, 581: {"01388e93-86b6-4586-90e0-1c79322c7cc1": 1}, 584: {583: 1}, 583: {"9bf1528c-824b-438d-932d-8d2dada8fd50": 1}, 585: {583: 1}, 586: {583: 1}, 588: {587: 1}, 587: {"7d66ad60-031a-402e-a7f8-1df120cce5c2": 1}, 590: {589: 1}, 589: {"36459016-a15c-40a7-9254-91ede6ad37e7": 1}, 592: {591: 1}, 591: {"7359ee75-84b8-4d58-aaa1-e55cdf40ed7f": 1}, 593: {591: 1}, 595: {594: 1}, 594: {"451641b0-cc93-4123-81bd-a593fa247ea2": 1}, 597: {596: 1}, 596: {"dc7fdbcb-72b3-4234-87e8-05d11d23361f": 1}, 599: {598: 1}, 598: {"8d965027-56b0-4b5b-bb38-05f2f2a3aa04": 1}, 600: {598: 1}, 602: {601: 1}, 601: {"944c3092-59b2-4200-a5ba-95532552d586": 1}, 604: {603: 1}, 603: {"aeb45d19-df6e-4aaa-a167-74593165f148": 1}, 606: {605: 1}, 605: {"9dbae020-55fd-4511-bb9f-23f0336e98b5": 1}, 607: {605: 1}, 609: {608: 1}, 608: {"fe42900d-e6fc-4c74-bf92-ecf398298382": 1}, 611: {610: 1}, 610: {"c315e557-0b4d-4007-8061-188b7add29cb": 1}, 613: {612: 1}, 612: {"a1c7d287-6ef2-495d-97d0-8e72a2165969": 1}, 614: {612: 1}, 616: {615: 1}, 615: {"f94b659f-8101-4724-997f-4e4acb67b633": 1}, 618: {617: 1}, 617: {"1a3c21a3-1ee7-49d7-82a0-53bf32562166": 1}, 620: {619: 1}, 619: {"e1e8456f-8b2e-4c78-a786-e4578997baaa": 1}, 622: {621: 1}, 621: {"0554f77f-db14-4d2d-ab99-922b0a7c024d": 1}, 624: {623: 1}, 623: {"0dc2b623-ec68-4fc8-80f3-87d8211915f8": 1}, 626: {625: 1}, 625: {"0e6bb5aa-6fa7-4ef3-a64a-14be7f8be1c1": 1}, 628: {627: 1}, 627: {"80a07ddf-cb7d-4124-adbc-84e9b4a8ed37": 1}, 630: {629: 1}, 629: {"8990b23c-c166-4ae1-9e00-167683bdb6df": 1}, 632: {631: 1}, 631: {"dee8c4a6-0fca-4087-8565-7ac67a7372f7": 1}, 634: {633: 1}, 633: {"6d2eeea2-39d7-480e-8bd4-35599cf5fb17": 1}, 636: {635: 1}, 635: {"49b3ffc8-5be7-4962-b782-c1f7bebea37c": 1}, 638: {637: 1}, 637: {"47874393-18d6-48e9-8090-f5160ea460bb": 1}, 640: {639: 1}, 639: {"1c154be0-8314-497c-b2c7-ee09a6f7b47c": 1}, 642: {641: 1}, 641: {"ce36a590-d9d7-4921-b4ee-ae271fcbd579": 1}, 644: {643: 1}, 643: {"f2b8e1c3-05ce-43f2-82ee-44121803d3dc": 1}, 645: {643: 1}, 646: {643: 1}, 647: {643: 1}, 648: {643: 1}, 650: {649: 1}, 649: {"15bf5661-0bec-48d8-bb0f-83e551e1e0a9": 1}, 652: {651: 1}, 651: {"b2ae7ffe-8565-4f0a-bc6a-d79924f4b130": 1}, 654: {653: 1}, 653: {"3e391d20-e4a9-4db1-a10e-a9c16101c883": 1}, 656: {655: 1}, 655: {"eb8b786a-6d0e-44cd-a0fb-2b66c5ba94b2": 1}, 658: {657: 1}, 657: {"191cf3a0-86b1-4fa2-b410-b5bf350c5045": 1}, 660: {659: 1}, 659: {"91e10c8d-110b-4c81-be81-d34f63d4f75a": 1}, 662: {661: 1}, 661: {"5b9c81cc-ff5a-4ba3-afb9-ac02c12f8b52": 1}, 664: {663: 1}, 663: {"5dcf1a64-ae14-444a-9c25-3c0a9a9806d9": 1}, 665: {663: 1}, 666: {663: 1}, 667: {663: 1}, 668: {663: 1}, 670: {669: 1}, 669: {"c7fae59c-ebf1-4ccd-bfc5-2ed48da49834": 1}, 672: {671: 1}, 671: {"b39da577-f07c-48db-b6ee-10afecde4d7a": 1}, 674: {673: 1}, 673: {"a9fb7fc7-549f-414c-af5b-7842998e8b2e": 1}, 676: {675: 1}, 675: {"e4c2277d-9448-4dcb-a7f9-da060ee0516a": 1}, 678: {677: 1}, 677: {"3db0efe1-95e8-4951-b884-f77d63e68d00": 1}, 680: {679: 1}, 679: {"bc239422-7b45-44e4-b00f-398f75a2a52f": 1}, 682: {681: 1}, 681: {"2f6f3214-3b99-4b82-b565-92b481f56a65": 1}, 684: {683: 1}, 683: {"85e3c342-0d86-40f8-9619-badd267879c3": 1}, 686: {685: 1}, 685: {"04f4f557-29c0-416e-9c2e-c20d5631574b": 1}, 688: {687: 1}, 687: {"73359fb0-aead-4daf-93e8-9f284aefb32f": 1}, 690: {689: 1}, 689: {"cf4aa89c-b905-4e13-adba-c0e065022571": 1}, 692: {691: 1}, 691: {"4213325b-b1f3-4a87-9f61-4e1812f806f5": 1}, 693: {691: 1}, 694: {691: 1}, 695: {691: 1}, 696: {691: 1}, 698: {697: 1}, 697: {"45aaa1d9-f759-412d-93ac-c645bc08b4b5": 1}, 700: {699: 1}, 699: {"93c39415-a801-46f6-b734-3004ff610e25": 1}, 702: {701: 1}, 701: {"1e2bae11-f1c8-4654-9f99-92f6788750d7": 1}, 704: {703: 1}, 703: {"271f872d-6071-462b-8cae-c1c413eabd23": 1}, 706: {705: 1}, 705: {"cf8f75f2-c4ca-4228-a210-2a540c899647": 1}, 708: {707: 1}, 707: {"49f3ac6e-dc6e-4962-8a78-b98f25fbcd0e": 1}, 710: {709: 1}, 709: {"15866fa7-ad28-4bda-9fd7-abda612b4095": 1}, 712: {711: 1}, 711: {"43daa433-514a-4812-af5b-e7e23eafc4bd": 1}, 713: {711: 1}, 714: {711: 1}, 715: {711: 1}, 716: {711: 1}, 718: {717: 1}, 717: {"f296c74b-6640-4415-a98a-5c65e9b2cf25": 1}, 719: {717: 1}, 721: {720: 1}, 720: {"20ab2153-21c1-4e47-ada9-4ab1ec51fc3d": 1}, 723: {722: 1}, 722: {"01cf6426-c744-4461-ba2e-3ff44f347a03": 1}, 725: {724: 1}, 724: {"4a654c26-4b50-45bf-a069-5062b494a7d5": 1}, 727: {726: 1}, 726: {"23dd93f3-0c8f-4121-9597-8e96645bcf3e": 1}, 729: {728: 1}, 728: {"0ae33ccd-5165-4886-b0b4-bbeddd38814b": 1}, 731: {730: 1}, 730: {"f0a86225-83f9-4ae2-81f7-6a44d41482dc": 1}, 732: {730: 1}, 733: {730: 1}, 735: {734: 1}, 734: {"c1aa91c7-985a-4d0f-9ee9-463d9ca426d3": 1}, 737: {736: 1}, 736: {"cc8f1a34-d150-45fa-aced-01853a757b1e": 1}, 739: {738: 1}, 738: {"2b4f1a40-b56b-4848-bf82-fd9d5a8b57c2": 1}, 741: {740: 1}, 740: {"cbe422c7-00c5-446b-ba62-ca33190c5653": 1}, 743: {742: 1}, + 742: {"06850c10-caf2-4061-a064-0b16186a2c17": 1},745: {744: 1}, + 744: {"28c5a495-d3a7-44d8-9170-0afa12275f09": 1},746: {744: 1}, + 747: {744: 1},749: {748: 1, 750: 1}, + 748: {"1712265e-da7a-47f6-8f61-f6bd8f331237": 1},750: {"2eedf055-b7eb-426f-9d88-f1fbe0d3cdf7": 1}, + 752: {751: 1},751: {"140be349-6873-46cd-a802-615775607e00": 1}, + } + # fmt: on + g = Graph(from_dict=d) + return g + + +def test_sycamore(): + g = sycamore() + assert isinstance(g, Graph) \ No newline at end of file diff --git a/graph-theory/source/tests/test_hashgraph.py b/graph-theory/source/tests/test_hashgraph.py new file mode 100644 index 0000000000000000000000000000000000000000..1a0351fe30e55e71bdc7f92961c5c207811c33d3 --- /dev/null +++ b/graph-theory/source/tests/test_hashgraph.py @@ -0,0 +1,112 @@ +from graph import Graph +from graph.hash_methods import graph_hash, flow_graph_hash, merkle_tree + + +def test_merkle_tree_1_block(): + data_blocks = [b"this"] + g = merkle_tree(data_blocks) + assert len(g.nodes()) == 1 + + +def test_merkle_tree_2_blocks(): + data_blocks = [b"this", + b"that"] + g = merkle_tree(data_blocks) + assert len(g.nodes()) == 3 + + +def test_merkle_tree_3_blocks(): + data_blocks = [b"this", + b"that", + b"them"] + g = merkle_tree(data_blocks) + assert len(g.nodes()) == 5 + + +def test_merkle_tree_4_blocks(): + data_blocks = [b"this", + b"that", + b"them", + b"they"] + g = merkle_tree(data_blocks) + assert len(g.nodes()) == 7 + + +def test_flow_graph_hash_01(): + """ + This example includes a loop to distinguish it from the common merkle tree. + + S-1 S-2 S-3 S-4 + (hash S1) (hash S2) (hash S3) (hash S4) + + + + + + | | +----------->+ + | | +<-------------+ + v v v | + I-1 I-2 | (loop) + (hash S1+S2+I1) (hash S3 + I2) | + + + + | + | | +------------->+ + v | | + E-1 +---> E-2 <------+ + (hash I1+E1) (hash I1+I2+E2) + + """ + links = [ + ('s-1', 'i-1', 1), + ('s-2', 'i-1', 1), + ('i-1', 'e-1', 1), + ('i-1', 'e-2', 1), + ('s-3', 'i-2', 1), + ('i-2', 'i-2', 1), + ('i-2', 'e-2', 1), + ] + g = Graph(from_list=links) + g.add_node('s-4') + g2 = flow_graph_hash(g) + assert len(g2.nodes()) == len(g.nodes()) + + +def test_flow_graph_loop_01(): + links = [ + (1, 2, 1), + (2, 3, 1), + (3, 4, 1), + (3, 2, 1) + ] + g = Graph(from_list=links) + g2 = flow_graph_hash(g) + assert len(g2.nodes()) == len(g.nodes()) + + +def test_flow_graph_async_01(): + """ + + (s1) --> (i2) --> (e4) + / + (s3) -->/ + """ + links = [ + (1, 2, 1), + (2, 4, 1), + (3, 4, 1) + ] + g = Graph(from_list=links) + g2 = flow_graph_hash(g) + assert len(g2.nodes()) == len(g.nodes()) + + +def test_graph_hash(): + """ + Simple test of the graph hash function. + """ + links = [ + (1, 2, 1), + (2, 3, 1), + (3, 4, 1), + (3, 2, 1) + ] + g = Graph(from_list=links) + h = graph_hash(g) + assert isinstance(h, int) + assert sum((int(d) for d in str(h))) == 312 + diff --git a/graph-theory/source/tests/test_random.py b/graph-theory/source/tests/test_random.py new file mode 100644 index 0000000000000000000000000000000000000000..913bfedaf1b7f1c0e9b7f0ae982e0e39374caf5d --- /dev/null +++ b/graph-theory/source/tests/test_random.py @@ -0,0 +1,58 @@ +from graph import Graph +from graph.random import random_xy_graph + + +def graph07(): + nodes = 10 + links = 30 + g = random_xy_graph(nodes=nodes, edges=links, x_max=800, y_max=400, seed=42) + assert isinstance(g, Graph) + assert len(g.nodes()) == nodes + assert len(g.edges()) == links + return g + + +def test_random_graph(): + g = graph07() + assert isinstance(g, Graph) + + +def test_random_graph_2(): + nodes = 10000 + links = 1 + + err1 = err2 = "" + try: + g = random_xy_graph(nodes=nodes, edges=links, x_max=80, y_max=40, seed=42) + except ValueError as e: + err1 = str(e) + pass + nodes = 10 + links = (sum(range(nodes)) * 2) + 1 + try: + g = random_xy_graph(nodes=nodes, edges=links, x_max=800, y_max=400, seed=42) + except ValueError as e: + err2 = str(e) + pass + assert str(err1) != str(err2) + + links = 1 + g = random_xy_graph(nodes=nodes, edges=links, x_max=7, y_max=2, seed=42) + # the xy_space above is so small that the generator must switch from random + # mode, to search mode. + + links = nodes * nodes # this is a fully connected graph. + g = random_xy_graph(nodes=nodes, edges=links, x_max=800, y_max=400, seed=42) + + # edges=None creates a fully connected graph + g2 = random_xy_graph(nodes=nodes, edges=None, x_max=800, y_max=400, seed=42) + assert len(g.nodes()) == len(g2.nodes()) + assert len(g.edges()) == len(g2.edges()) + + +def test_random_graph_4(): + """ check that the string method is correct. """ + g = random_xy_graph(1000, 1000, 1000, 7000) + assert len(g.edges()) == 7000 + s = str(g) + assert s == 'Graph(1000 nodes, 7000 edges)', s diff --git a/graph-theory/source/tests/test_search.py b/graph-theory/source/tests/test_search.py new file mode 100644 index 0000000000000000000000000000000000000000..1de31ee1dca5df1626ab0679859ae2b3a923b361 --- /dev/null +++ b/graph-theory/source/tests/test_search.py @@ -0,0 +1,722 @@ +import random +import time +from itertools import combinations, permutations + +from graph import Graph +from graph.base import same_path +from tests.test_graph import graph01, graph3x3, graph03, graph04, graph05, graph4x4 +from examples.graphs import london_underground + + +def test_same(): + assert same_path([1], [1]) + assert not same_path([1], [1, 1]) # same content, different length + assert not same_path([1], [2]) # different content + assert not same_path([1], [1, 2]) # different length and content + assert not same_path([1], [2, 1]) # different length and content + + L = list('attacca') + assert same_path(L, L) # uses python id to avoid work. + + assert same_path([1, 2], [1, 2]) # identical + assert same_path([1, 2], [2, 1]) # same but backwards + assert not same_path([1, 2, 1], [2, 1, 2]) # same length, content, but different frequency. + + +def test_shortest_path01(): + g = graph03() + dist_g, path_g = g.shortest_path(1, 8) + assert path_g == [1, 2, 4, 8], path_g + + h = graph04() + distH, pathH = g.shortest_path(1, 8) + assert pathH == [1, 2, 4, 8], pathH + pathH = pathH[2:] + pathH[:2] + assert path_g != pathH, (path_g, pathH) + + assert g.same_path(path_g, pathH) + assert h.same_path(path_g, pathH) + + reverseG = list(reversed(path_g)) + assert not g.same_path(path_g, reverseG) + + assert g.has_path(path_g) + + +def test_tsp(): + """ + Assures that the optimization method works. + + The greedy algorithm of the TSP solvers first method + will build this graph: + + (0)---(1)---(2)---(3)---(4) + + / + ---------------------------------------- + / + + (5)---(6)---(7)---(8)---(9) + + The method 'improve tour' will then reverse segments + if they improve the overall tour length. This leads to + this result: + + (0)---(1)---(2)---(3)---(4)--------------+ + + + + + + + + + + +-----------(5)---(6)---(7)---(8)---(9) + + which is a fraction shorter. + """ + g = Graph() + xys = [ + (0, 0), + (0, 1), + (0, 2), + (0, 3), + (0, 4), + (1, 3), + (1, 4), + (1, 5), + (1, 6), + (1, 7) + ] + + def _distance(a, b): + dx = abs(a[0] - b[0]) + dy = abs(a[1] - b[1]) + return (dx ** 2 + dy ** 2) ** (1 / 2) + + # The graph must be fully connected for the TSP to work: + for a, b in combinations(range(len(xys)), 2): + d = _distance(xys[a], xys[b]) + g.add_edge(a, b, value=d) + g.add_edge(b, a, value=d) + + dist, path = g.solve_tsp() + expected_tour = [0, 1, 2, 3, 4, 9, 8, 7, 6, 5] + expected_length = 14.32455532033676 + assert dist == expected_length, (dist, expected_length) + assert g.same_path(path, expected_tour) + + +def test_tsp_perfect_problem(): + """ + The tour is: + + (0,5)--(1,5)--(2,5)--(3,5)--(4,5)--(5,5) + | | + (0,4) (5,4) + | | + (0,3) (5,3) + | | + (0,2) (5,2) + | | + (0,1)--(1,1)--(2,1)--(3,1)--(4,1)--(5,1) + + And it must be 18 long. + """ + g = Graph() + xys = [ + (0, 1), (0, 2), (0, 3), (0, 4), (0, 5), + (1, 5), (2, 5), (3, 5), (4, 5), (5, 5), + (5, 4), (5, 3), (5, 2), + (5, 1), (4, 1), (3, 1), (2, 1), (1, 1), + ] + + def _distance(a, b): + dx = abs(a[0] - b[0]) + dy = abs(a[1] - b[1]) + return (dx ** 2 + dy ** 2) ** (1 / 2) + + # The graph must be fully connected for the TSP to work: + for a, b in combinations(range(len(xys)), 2): + d = _distance(xys[a], xys[b]) + g.add_edge(a, b, value=d) + g.add_edge(b, a, value=d) + + dist, path = g.solve_tsp() + expected_tour = [i for i in range(len(xys))] + expected_length = len(xys) + assert dist == expected_length, (dist, expected_length) + assert g.same_path(path, expected_tour) + + +def test_tsp_larger_problem(): + random.seed(44) + points = 200 + + xys = set() + while len(xys) != points: + xys.add((random.randint(0, 600), random.randint(0, 800))) + xys = [n for n in xys] + + g = Graph() + for a, b in combinations(xys, 2): + dx = abs(a[0] - b[0]) + dy = abs(a[1] - b[1]) + d = (dx ** 2 + dy ** 2) ** (1 / 2) + g.add_edge(a, b, value=d) + g.add_edge(b, a, value=d) + + start = time.process_time() + dist, path = g.solve_tsp() + end = time.process_time() + print("Running tsp on {} points, took {:.3f} seconds".format(points, end - start)) + assert len(path) == points + + +def test_shortest_path_fail(): + g = graph3x3() + d, p = g.shortest_path(start=9, end=1) # there is no path. + assert d == float('inf') + assert p == [] + + +def test_distance(): + g = graph3x3() + p = [1, 2, 3, 6, 9] + assert g.distance_from_path(p) == 4 + + try: + g.distance_from_path([1, 2, 3, 900]) # 900 doesn't exist. + assert False, "900 isn't in the graph." + except ValueError: + assert True + + +def test_bfs(): + g = graph03() + path = g.breadth_first_search(1, 7) + assert path == [1, 3, 7], path + + try: + g.breadth_first_search(1, 900) # 900 doesn't exit. + assert False, "900 isn't in the graph" + except ValueError: + assert True + + +def test_bfw(): + g = graph03() + bfw = g.breadth_first_walk(1) + walk = [n for n in bfw] + assert walk == [1, 2, 3, 4, 5, 6, 8, 7], walk + + bfw = g.breadth_first_walk(1, 5) + walk = [n for n in bfw] + assert walk == [1, 2, 3, 4, 5] + + +def test_distance_map(): + g = graph3x3() + d = g.distance_map(starts=1) + + assert all(d[i] == 1 for i in [2, 4]) + assert all(d[i] == 2 for i in [3, 5, 7]) + assert all(d[i] == 3 for i in [6, 8]) + assert all(d[i] == 4 for i in [9]) + + +def test_distance_map_fail(): + g = graph3x3() + d = g.distance_map(starts=9) # All edges end in 9, so the dict should contain nothing. + assert d == {9: 0} + + +def test_distance_map_reverse(): + g = graph3x3() + d = g.distance_map(ends=9, reverse=True) + assert d == {9: 0, 6: 1, 8: 1, 3: 2, 5: 2, 7: 2, 2: 3, 4: 3, 1: 4} + + +def test_distance_map_reverse_with_start(): + g = graph3x3() + g.add_edge(0, 1, 1) + d = g.distance_map(starts=[2, 4], ends=9, reverse=True) + assert d == {9: 0, + 6: 1, 8: 1, + 3: 2, 5: 2, 7: 2, + 2: 3, 4: 3, + 1: 4}, d + assert 0 not in d + + +def test_distance_map_with_starts_and_ends(): + g = graph3x3() + g.add_edge(0, 1, 1) + d = g.distance_map(starts=[2, 4], ends=[6, 8]) + assert d == {2: 0, 4: 0, + 3: 1, 5: 1, 7: 1, + 6: 2, 8: 2, + 9: 3}, d + assert 0 not in d + + +def test_distance_map_with_tailing_ends(): + g = Graph(from_list=[(1, 2, 1), (2, 3, 1), (3, 4, 1), (4, 5, 1), (5, 6, 1), (6, 7, 1)]) + d = g.distance_map(starts=1, ends=[3,5]) + assert d == {1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5}, d + assert 7 not in d + + +def test_distance_map_with_ends(): + g = graph3x3() + d = g.distance_map(starts=1, ends=5) + + assert d[5] == 2 + assert d == {1: 0, + 2: 1, 4: 1, + 3: 2, 5: 2, 7: 2, + 6: 3, 8: 3}, d + + +def test_distance_map_multiple_starts_and_ends(): + g = graph3x3() + d = g.distance_map(starts=[1, 3], ends=[7, 9]) + + assert d == {1: 0, 3: 0, + 2: 1, 4: 1, 6: 1, + 5: 2, 7: 2, 9: 2, + 8: 3}, d + + +def test_shortest_tree_all_pairs01(): + g = Graph() + links = [ + (1, 2, 1), + (1, 3, 1), + (2, 3, 1) + ] + for L in links: + g.add_edge(*L) + + p = g.shortest_tree_all_pairs() + assert p == [1, 2, 3] + + +def test_shortest_tree_all_pairs02(): + links = [ + (1, 2, 1), + (1, 3, 2), + (2, 3, 3) + ] + g = Graph(from_list=links) + + for L in links: + g.add_edge(*L) + + p = g.shortest_tree_all_pairs() + assert p == [1, 2, 3] + + +def test_all_paths_no_path(): + """ + [1] --> [2] [3] --> [4] + """ + g = Graph(from_list=[(1, 2, 1), (3, 4, 1)]) + paths = g.all_paths(1, 4) + assert paths == [] + + +def test_all_paths_start_is_end(): + g = graph3x3() + try: + g.all_paths(2, 2) + raise AssertionError("a value error should have been raised.") + except ValueError: + pass + + +def test_all_paths01(): + g = graph3x3() + paths = g.all_paths(1, 3) + assert len(paths) == 1, paths + assert paths[0] == [1, 2, 3] + + +def test_all_paths02(): + g = graph3x3() + paths = g.all_paths(1, 6) + assert len(paths) == 3 + expected = [[1, 2, 3, 6], [1, 2, 5, 6], [1, 4, 5, 6]] + assert all(i in expected for i in paths) and all(i in paths for i in expected) + + +def test_all_paths03(): + g = graph3x3() + paths = g.all_paths(1, 9) + assert len(paths) == 6 + expected_result = [[1, 2, 3, 6, 9], + [1, 2, 5, 6, 9], + [1, 2, 5, 8, 9], + [1, 4, 5, 6, 9], + [1, 4, 5, 8, 9], + [1, 4, 7, 8, 9]] + assert all(i in expected_result for i in paths) and all(i in paths for i in expected_result) + + +def test_all_paths04(): + g = Graph(from_list=[(1, 2, 1), (1, 3, 1), (2, 4, 1), (3, 4, 1)]) + paths = g.all_paths(1, 4) + expected = [[1, 2, 4], [1, 3, 4]] + assert all(i in expected for i in paths) and all(i in paths for i in expected) + + +def test_all_paths05(): + """ + [1] --> [2] --> [3] --> [4] --> [5] + ^ | + | v + [10] --> +<---- [6] <----+ + ^ | + | v + [9] <-- [8] <-- [7] + + """ + links = [(1, 2), (2, 3), (3, 4), (4, 5), (4, 6), (6, 2), (6, 7), (7, 8), (8, 9), (9, 10), (10, 2)] + g = Graph(from_list=[(a, b, 1) for a, b in links]) + paths = g.all_simple_paths(start=1, end=5) + assert paths == [[1, 2, 3, 4, 5]] + + paths = g.all_paths(start=1, end=5) + expected = [[1, 2, 3, 4, 5], + [1, 2, 3, 4, 6, 2, 3, 4, 5], + [1, 2, 3, 4, 6, 7, 8, 9, 10, 2, 3, 4, 5]] + assert all(i in expected for i in paths) and all(i in paths for i in expected), paths + + +def test_all_paths06(): + links = [(1, 2), (2, 3), (3, 4), (4, 5), (4, 6), (6, 2), (6, 7), (7, 8), (8, 9), (9, 10), (10, 2)] + g = Graph(from_list=[(a, b, 1) for a, b in links]) + for comb in permutations(list(range(1, 11)), 2): + start, end = comb + paths = g.all_paths(start, end) + for path in paths: + assert (path[0], path[-1]) == (start, end), path + assert True, "All permutations of start and end passed." + + +def test_all_simple_paths(): + """ + [1] -- [2] -- [3] + | / | + [4] -- [5] + """ + g = Graph() + edges = (1, 2), (2, 3), (2, 4), (3, 4), (3, 5), (4, 5) + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + paths = g.all_simple_paths(start=5, end=1) + expected = [[5, 3, 2, 1], [5, 4, 2, 1], [5, 3, 4, 2, 1], [5, 4, 3, 2, 1]] + assert all(i in expected for i in paths) and all(i in paths for i in expected) + + +def test_dfs(): + links = [ + (1, 2, 0), + (1, 3, 0), + (2, 3, 0), + (2, 4, 0), + (3, 4, 0) + ] + g = Graph(from_list=links) + try: + g.depth_first_search(0, 2) + assert False, "node 0 is not in g" + except ValueError: + pass + + try: + g.depth_first_search(1, 99) + assert False, "node 99 is not in g" + except ValueError: + pass + + path = g.depth_first_search(1, 4) + assert g.has_path(path) + + path = g.depth_first_search(4, 1) + assert path is None, path + + +def test_dfs_on_cycle(): + edges = [ + (1, 2, 1), + (2, 3, 1), + (3, 2, 1), + ] + for i in range(3, 10, 1): + edge = (i, i + 1, 1) + edges.append(edge) + g = Graph(from_list=edges) + path = g.depth_first_search(start=1, end=9) + assert path is not None, path + + +def test_dfs_02(): + links = [ + (1, 2, 0), + (1, 3, 0), + (3, 5, 0), + (2, 4, 0), + (5, 6, 0), + ] + g = Graph(from_list=links) + path = g.depth_first_search(1, 4) + assert path == [1, 2, 4] + assert g.has_path(path) + + +def test_dfs_03(): + g = graph05() + path = g.depth_first_search(0, 10) + assert path == [0, 2, 3, 9, 10] + assert g.has_path(path) + + +def test_depth_scan_01(): + links = [ + (1, 2, 0), + (1, 3, 0), + (3, 5, 0), + (2, 4, 0), + (5, 6, 0), + ] + g = Graph(from_list=links) + + def visit_node(node) -> bool: + return node != 2 + + visited = g.depth_scan(1, visit_node) + assert len(visited) == 5 + assert 1 in visited + assert 2 in visited + assert 3 in visited + assert 5 in visited + assert 6 in visited + assert 4 not in visited + + +def test_depth_scan_02(): + """ criteria not callable""" + g = graph01() + + criteria = 41 # not callable + try: + g.depth_scan(1, criteria) + assert False, "criteria must be a callable, so this is not possible" + except TypeError: + assert True + + +def test_depth_scan_03(): + """ start not in graph """ + g = graph01() + start_that_doesnt_exist = max(g.nodes()) + 1 + + def criteria(n): + return False + + try: + g.depth_scan(start_that_doesnt_exist, criteria) + assert False, "start isn't in g, so reaching this code isn't possible." + except ValueError: + assert True + + +def test_depth_scan_04(): + """ criteria negative on start""" + g = graph01() + + def criteria(n): + return False + + empty_set = set() + assert g.depth_scan(1, criteria) == empty_set + + +def test_depth_scan_05(): + g = graph01() + + def criteria(n): + return n < 5 + + result = g.depth_scan(1, criteria) + assert max(result) == 5, result + + +def test_degree_of_separation(): + g = graph05() + assert g.degree_of_separation(0, 10) == 3 + + +def test_loop(): + g = graph4x4() + p = Graph.loop(g, 1, 16) + assert p == [1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 1] + + +def test_avoids(): + g = graph4x4() + d, p = Graph.shortest_path(g, 1, 16, avoids={3, 7, 11, 10}) + assert p == [1, 5, 9, 13, 14, 15, 16], p + + +def test_incomparable_path_searching(): + """ + incomparable type A -> incomparable type A -> incomparable type B + | + v + incomparable type C + """ + g = Graph() + g.add_edge(("A", "6"), ("B", "7")) + g.add_edge(("A", "6"), 6) + g.add_edge(("B", "7"), "B") + + p = g.all_paths(("A", "6"), "B") + assert p == [[("A", "6"), ("B", "7"), "B"]] + + p = g.depth_first_search(("A", "6"), "B") + assert p == [("A", "6"), ("B", "7"), "B"] + + p = g.breadth_first_search(("A", "6"), "B") + assert p == [("A", "6"), ("B", "7"), "B"] + + p = g.shortest_path(("A", "6"), "B") + assert p == (2, [("A", "6"), ("B", "7"), "B"]) + + +def test_memoize(): + g = Graph() + g.add_edge(0, 1) + g.add_edge(1, 2) + g.add_edge(2, 3) + + # Python interprets 0 as False which has nasty side effects. + assert g.shortest_path(0, 3, memoize=False) == (3, [0,1,2,3]) + assert g.shortest_path(0, 3, memoize=True) == (3, [0,1,2,3]) + +def test_memoize_bidi(): + g = Graph() + g.add_edge(1, 2, 1, bidirectional=True) + g.add_edge(0, 1, 1, bidirectional=True) + g.add_edge(2, 3, 1, bidirectional=True) + + # Python interprets 0 as False which has nasty side effects. + assert g.shortest_path(0, 3, memoize=False) == (3, [0,1,2,3]) + assert g.shortest_path(3, 0, memoize=False) == (3, [3,2,1,0]) + assert g.shortest_path(0, 3, memoize=True) == (3, [0,1,2,3]) + assert g.shortest_path(3, 0, memoize=True) == (3, [3,2,1,0]) + + +def test_cached_graph(): + g = Graph(from_list=[(s, e, d + (s / 100)) for s, e, d in graph4x4().edges()]) + g2 = g.copy() + a, b = 1, 16 + d2, p2 = g2.shortest_path(a, b, memoize=True) + d1, p1 = g.shortest_path(a, b) + assert d1 == d2, (d1, d2) + assert p1 == p2, (p1, p2) + + +def test_cached_graph_no_path(): + """ + Returns for a cached graph should be the same as for an uncached graph. + [1] --> [2] [3] --> [4] + """ + g = Graph(from_list=[(1, 2, 1), (3, 4, 1)]) + + # for no path + d1, p1 = g.shortest_path(1, 4) + assert d1 == float("inf") + assert p1 == [] + + d2, p2 = g.shortest_path(1, 4, memoize=True) + assert d1 == d2 + assert p1 == p2 + + # for same start and end + d1, p1 = g.shortest_path(1, 1) + assert d1 == 0 + assert p1 == [1] + + d2, p2 = g.shortest_path(1, 1, memoize=True) + assert d1 == d2 + assert p1 == p2 + + +def test_cached_graph2(): + g = london_underground() + seds = list(g.edges()) + for s, e, d in seds: + g.add_edge(s, e, d + s / len(seds) ** 2) # adding minor variances so that no paths are the same length. + + r1 = g.shortest_path(74, 89, memoize=True) + r2 = g.shortest_path(74, 89, memoize=True) + assert r1 == r2, "cache call should be the same as the previous" + r3 = g.shortest_path(99, 89, memoize=True) # this is a cache call as p(99,89) is in p(74,89) + assert r3 == (12.00290022249407, [99, 236, 229, 273, 107, 192, 277, 89]), r3 + + a1, b1 = 10, 89 + for a, b in combinations(g.nodes(), 2): + if a == a1 and b == b1: + d1, p1 = g.shortest_path(a, b) + d2, p2 = g.shortest_path(a, b, memoize=True) + d3, p3 = g.shortest_path_bidirectional(a, b) + assert d1 == d2 == d3 + assert p1 == p2 == p3, (p1, p2, p3) + + break + else: + g.shortest_path(a, b, memoize=True) + + +def test_cached_graph3(): + g = Graph() + g.add_edge(1, 2, 3, False) + g.add_edge(2, 3, 4, False) + g.add_edge(1, 3, 10, False) + p1 = g.shortest_path(1, 3) + assert p1 == (7, [1, 2, 3]) + p2 = g.shortest_path(1, 3, memoize=True) + assert p1 == p2 + + +def test_incremental_search(tests=2000): + g = london_underground() + + seds = list(g.edges()) + for s, e, d in seds: + g.add_edge(s, e, d + s / len(seds) ** 2) # adding minor variances so that no paths are the same length. + + g2 = g.copy() + + t_repeated, t_memoized, cnt = 0.0, 0.0, 0 + + for a, b in combinations(g.nodes(), 2): + for repetition in range(5): + start = time.process_time() + d1, p1 = g.shortest_path(a, b) + end = time.process_time() + t_repeated += end - start + + start = time.process_time() + d2, p2 = g2.shortest_path(a, b, memoize=True) + end = time.process_time() + t_memoized += end - start + assert d1 == d2, (a, b, d1, d2) + assert p1 == p2, (p1, p2) + + cnt += 1 + + if cnt > tests: + break + + pct = f"{round(100 * t_memoized / t_repeated)}" if t_repeated > 0 else "?" + print("repeated searches", t_repeated, "secs.", + "\nmemoized searches:", t_memoized, "secs.", + "\ntime using memoising: ", pct, "% of repeated searches", + flush=True) + assert t_repeated >= t_memoized diff --git a/graph-theory/source/tests/test_spatial_graph.py b/graph-theory/source/tests/test_spatial_graph.py new file mode 100644 index 0000000000000000000000000000000000000000..04750f2f3a16cacd5dc08a86ed51e00f0b48b844 --- /dev/null +++ b/graph-theory/source/tests/test_spatial_graph.py @@ -0,0 +1,283 @@ +from math import sin, cos, isclose +from graph import Graph3D + + +def spiral_graph(): + xyz = [(sin(i / 150), cos(i / 150), i / 150) for i in range(0, 1500, 30)] + g = Graph3D() + for t in xyz: + g.add_node(t) + + xyz.sort(key=lambda x: x[2]) # sorted by z axis which is linear. + + n1 = xyz[0] + for n2 in xyz[1:]: + distance = g.distance(n1, n2) + g.add_edge(n1, n2, distance) + n1 = n2 + return g + + +def fishbone_graph(levels=5, lengths=10, depths=2): + """ Creates a multi level fishbone graph. + + :param levels: int: number of levels + :param lengths: int: number of ribs + :param depths: int: number of joints on each rib. + :return: Graph3D + """ + g = Graph3D() + prev_level = None + for level in range(1, levels+1): # z axis. + g.add_node((0, 0, level)) + if prev_level is None: + pass + else: + g.add_edge((0, 0, prev_level), (0, 0, level), value=1, bidirectional=True) + + prev_spine = (0, 0, level) # the lift. + for step in range(1, lengths+1): # step along the x axis. + spine = (step, 0, level) + g.add_edge(prev_spine, spine, 1, bidirectional=True) + + for side in [-1, 1]: + rib_1 = spine + for depth in range(1, depths+1): + rib_2 = (step, side * depth, level) + g.add_edge(rib_1, rib_2, 1, bidirectional=True) + rib_1 = rib_2 + + prev_spine = spine + prev_level = level + + g.add_node((-1, 0, 2)) # entry point + g.add_edge((-1, 0, 2), (0, 0, 2), 1, bidirectional=True) + g.add_node((-1, 0, 1)) # exit point + g.add_edge((-1, 0, 1), (0, 0, 1), 1, bidirectional=True) + return g + + +def test_basics(): + g = Graph3D() + a, b, c = (0, 0, 0), (1, 1, 1), (2, 2, 2) + g.add_node(a) + g.add_node(b) + g.add_node(c) + assert g.n_nearest_neighbours(a)[0] == b + assert g.n_nearest_neighbours(c)[0] == b + + L = g.to_list() + g2 = Graph3D(from_list=L) + assert g2.nodes() == g.nodes() + assert g2.edges() == g.edges() + + d = g.to_dict() + g3 = Graph3D(from_dict=d) + assert g3.nodes() == g.nodes() + assert g3.edges() == g.edges() + + g4 = g.copy() + assert g4.edges() == g.edges() + + +def test_path_finding(): + xyz = [(sin(i / 150), cos(i / 150), i / 150) for i in range(0, 1500, 30)] + g = Graph3D() + for t in xyz: + g.add_node(t) + + xyz.sort(key=lambda x: x[2]) + + total_distance = 0.0 + n1 = xyz[0] + for n2 in xyz[1:]: + distance = g.distance(n1, n2) + total_distance += distance + g.add_edge(n1, n2, distance) + n1 = n2 + + d, p = g.shortest_path(xyz[0], xyz[-1]) + assert isclose(d, 13.847754085278877), d + assert p == xyz, [(idx, a, b) for idx, (a, b) in enumerate(zip(p, xyz)) if a != b] + + +def test_shortest_path(): + """ assure that the fishbone graphs entry and exits are connected. """ + g = fishbone_graph() + entry_point = (-1, 0, 2) + exit_point = (-1, 0, 1) + d, p = g.shortest_path(entry_point, exit_point) + assert d == 3, d + + +def test_no_nearest_neighbour(): + """ checks that when you're alone, you have no neighbours.""" + g = Graph3D() + xyz = (1, 1, 1) + g.add_node(xyz) + assert g.n_nearest_neighbours(xyz) is None + + +def test_bfs(): + g = fishbone_graph() + entry_point = (-1, 0, 2) + exit_point = (-1, 0, 1) + p = g.breadth_first_search(entry_point, exit_point) + assert len(p) == 4, p + + +def test_dfs(): + g = fishbone_graph() + entry_point = (-1, 0, 2) + exit_point = (-1, 0, 1) + p = g.depth_first_search(entry_point, exit_point) + assert len(p) == 4, p + + +def test_distance_from_path(): + g = fishbone_graph() + entry_point = (-1, 0, 2) + exit_point = (-1, 0, 1) + p = g.breadth_first_search(entry_point, exit_point) + assert len(p) == 4 + assert g.distance_from_path(p) == 3 + + +def test_maximum_flow(): + g = fishbone_graph() + entry_point = (-1, 0, 2) + exit_point = (-1, 0, 1) + total_flow, flow_graph = g.maximum_flow(entry_point, exit_point) + assert total_flow == 1, total_flow + assert len(flow_graph.nodes()) == 4, len(flow_graph.nodes()) + + +def test_subgraph_from_nodes(): + g = fishbone_graph() + entry_point = (-1, 0, 2) + exit_point = (-1, 0, 1) + p = g.breadth_first_search(entry_point, exit_point) + subgraph = g.subgraph_from_nodes(p) + assert isinstance(subgraph, Graph3D), type(subgraph) + new_p = subgraph.breadth_first_search(entry_point, exit_point) + assert p == new_p, (p, new_p) + + +def test_has_cycles(): + g = Graph3D() + a, b, c = (0, 0, 0), (1, 1, 1), (2, 2, 2) + g.add_edge(a, b, 1) + g.add_edge(b, c, 1) + assert not g.has_cycles() + g.add_edge(c, a, 1) + assert g.has_cycles() + + +def test_network_size(): + g = fishbone_graph(levels=3, lengths=3, depths=3) + entry_point = (-1, 0, 2) + assert g.network_size(entry_point) + + +def test_has_path(): + g = Graph3D() + a, b, c = (0, 0, 0), (1, 1, 1), (2, 2, 2) + g.add_edge(a, b, 1) + g.add_edge(b, c, 1) + assert not g.has_path([c, a, b, c]) + g.add_edge(c, a, 1) + assert g.has_path([c, a, b]) + assert g.has_path([a, b, c]) + + +def test_degree_of_separation(): + g = fishbone_graph() + entry_point = (-1, 0, 2) + exit_point = (-1, 0, 1) + des = g.degree_of_separation(entry_point, exit_point) + assert des == 3 + + +def test_number_of_components(): + g = fishbone_graph(3, 3, 3) + cs = g.components() + assert len(cs) == 1, cs + + g = fishbone_graph() + cs = g.components() + assert len(cs) == 1, cs + + +def test_bad_config(): + g = Graph3D() + try: + g.distance((1, 2), (3, 4)) + raise AssertionError + except ValueError: + pass + + try: + g.add_edge(1, 2) + raise AssertionError + except TypeError: + pass + + try: + g.add_edge((1,), (2,)) + raise AssertionError + except ValueError: + pass + + try: + g.add_edge((1, 2, 3), (2,)) + raise AssertionError + except ValueError: + pass + + try: + g.add_edge((1, 2, 3), 2) + raise AssertionError + except TypeError: + pass + + try: + g.add_edge((1.0, 1.0, 1.0), (1, 1.0, "1")) + raise AssertionError + except TypeError: + pass + + try: + g.add_node(1) + raise AssertionError + except TypeError: + pass + + try: + g.add_node((1,)) + raise AssertionError + except ValueError: + pass + + try: + g.n_nearest_neighbours(1) + raise AssertionError + except TypeError: + pass + + try: + g.n_nearest_neighbours((1,)) + raise AssertionError + except ValueError: + pass + + try: + g.n_nearest_neighbours((1, 2, 3), n='abc') + raise AssertionError + except TypeError: + pass + + try: + g.n_nearest_neighbours((1, 2, 3), n=-1) + raise AssertionError + except ValueError: + pass diff --git a/graph-theory/source/tests/test_topology.py b/graph-theory/source/tests/test_topology.py new file mode 100644 index 0000000000000000000000000000000000000000..0f3cb4e4befe600145016127caafedbf969c93ed --- /dev/null +++ b/graph-theory/source/tests/test_topology.py @@ -0,0 +1,428 @@ +import time +from graph import Graph +from graph.critical_path import Task, critical_path, critical_path_minimize_for_slack +from graph.dag import phase_lines +from tests import profileit +from tests.test_graph import ( + graph02, + graph3x3, + graph_cycle_6, + graph_cycle_5, + fully_connected_4, + mountain_river_map, + sycamore, + small_project_for_critical_path_method, +) + + +def test_subgraph(): + g = graph3x3() + g2 = g.subgraph_from_nodes([1, 2, 3, 4]) + d = { + 1: {2: 1, 4: 1}, + 2: {3: 1}, + } + assert g2.is_subgraph(g) + for k, v in d.items(): + for k2, d2 in v.items(): + assert g.edge(k, k2) == g2.edge(k, k2) + + g3 = graph3x3() + g3.add_edge(3, 100, 7) + assert not g3.is_subgraph(g2) + + +def test_is_partite(): + g = graph_cycle_6() + bol, partitions = g.is_partite(n=2) + assert bol is True + + g = graph_cycle_5() + bol, part = g.is_partite(n=2) + assert bol is False + bol, part = g.is_partite(n=5) + assert bol is True + assert len(part) == 5 + + +def test_is_cyclic(): + g = graph_cycle_5() + assert g.has_cycles() + + +def test_is_not_cyclic(): + g = graph3x3() + assert not g.has_cycles() + +def test_has_cycles(): + g = Graph(from_list=[(1, 2), (2, 3), (3, 1)]) + assert g.has_cycles() + g.add_node(4) + assert g.has_cycles() + + g.add_edge(4,5) + assert g.has_cycles() + g.add_edge(5,4) + assert g.has_cycles() + + +def test_is_really_cyclic(): + g = Graph(from_list=[(1, 1, 1), (2, 2, 1)]) # two loops onto themselves. + assert g.has_cycles() + + +def test_components(): + g = Graph( + from_list=[ + (1, 2, 1), # component 1 + (2, 1, 1), + (3, 3, 1), # component 2 + (4, 5, 1), + (5, 6, 1), # component 3 + (5, 7, 1), + (6, 8, 1), + (7, 8, 1), + (8, 9, 1), + ] + ) + g.add_node(10) # component 4 + components = g.components() + assert len(components) == 4 + assert {1, 2} in components + assert {3} in components + assert {4, 5, 6, 7, 8, 9} in components + assert {10} in components + + +def test_network_size(): + g = graph3x3() + ns1 = g.network_size(n1=1) + assert len(ns1) == 9 # all nodes. + + ns1_2 = g.network_size(n1=1, degrees_of_separation=2) + assert all(i not in ns1_2 for i in [6, 8, 9]) + + ns5 = g.network_size(n1=5) + assert len(ns5) == 4 # all nodes downstream from 5 (plus 5 itself) + + ns9 = g.network_size(n1=9) + assert len(ns9) == 1 # just node 9, as there are no downstream peers. + + +def test_network_size_when_fully_connected(): + """tests network size when the peer has already been seen during search.""" + g = fully_connected_4() + ns = g.network_size(n1=1) + assert len(ns) == len(g.nodes()) + + +def test_phase_lines_with_loop(): + g = graph3x3() + g.add_edge(9, 1) + try: + _ = g.phase_lines() + assert False, "the graph is cyclic" + except AttributeError: + assert True + + +def test_phase_lines_with_inner_loop(): + g = graph3x3() + g.add_edge(9, 2) + try: + _ = g.phase_lines() + assert False, "the graph is cyclic" + except AttributeError: + assert True + + +def test_phase_lines_with_inner_loop2(): + g = graph3x3() + g.add_edge(3, 2) + try: + _ = g.phase_lines() + assert False, "the graph is cyclic" + except AttributeError: + assert True + + +def test_phase_lines_with_inner_loop3(): + g = graph3x3() + g.add_edge(9, 10) + g.add_edge(10, 5) + try: + _ = g.phase_lines() + assert False, "the graph is cyclic" + except AttributeError: + assert True + + +def test_offset_phase_lines(): + """ + This test recreates a bug + + 1 + | + 2 + | + 3 <--- + | / | + 4 A ^ + | | | + 5 B | + |___| / + 6____/ + | + 7 + + """ + g = Graph( + from_list=[ + (1, 2, 1), + (2, 3, 1), + (3, 4, 1), + (4, 5, 1), + (5, 6, 1), + (6, 7, 1), + (6, 4, 1), + ("a", "b", 1), + ("b", 6, 1), + ] + ) + try: + _ = g.phase_lines() + assert False, "the graph is cyclic" + except AttributeError: + assert True + + +def test_phaselines(): + """ + 1 +---> 3 +--> 5 +---> 6 [7] + ^ ^ + +------------+ | + | + 2 +---> 4 +----------> + + """ + g = Graph( + from_list=[ + (1, 3, 1), + (2, 4, 1), + (2, 5, 1), + (3, 5, 1), + (4, 6, 1), + (5, 6, 1), + ] + ) + g.add_node(7) + + p = g.phase_lines() + assert set(g.nodes()) == set(p.keys()) + expects = {1: 0, 2: 0, 7: 0, 3: 1, 4: 1, 5: 2, 6: 3} + assert p == expects, (p, expects) + + +def test_phaselines_for_ordering(): + """ + u1 u4 u2 u3 + | | |_______| + csg cs3 append + | | | + op1 | op3 + | | | + op2 | cs2 + | |___________| + cs1 join + | | + map1 map2 + |___________| + save + + """ + L = [ + ("u1", "csg", 1), + ("csg", "op1", 1), + ("op1", "op2", 1), + ("op2", "cs1", 1), + ("cs1", "map1", 1), + ("map1", "save", 1), + ("u4", "cs3", 1), + ("cs3", "join", 1), + ("join", "map2", 1), + ("map2", "save", 1), + ("u2", "append", 1), + ("u3", "append", 1), + ("append", "op3", 1), + ("op3", "cs2", 1), + ("cs2", "join", 1), + ] + + g = Graph(from_list=L) + + p = g.phase_lines() + + expected = { + "u1": 0, + "u4": 0, + "u2": 0, + "u3": 0, + "csg": 1, + "cs3": 1, + "append": 1, + "op1": 2, + "op3": 2, + "op2": 3, + "cs2": 3, + "cs1": 4, + "join": 4, + "map1": 5, + "map2": 5, + "save": 6, + } + + assert p == expected, {(k, v) for k, v in p.items()} - {(k, v) for k, v in expected.items()} + + +def test_phaselines_for_larger_graph(): + g = mountain_river_map() + start = time.time() + p = g.phase_lines() + g.has_cycles() + end = time.time() + + # primary objective: correctness. + assert len(p) == 253, len(p) + + # secondary objective: timeliness + assert end - start < 1 # second. + + # third objective: efficiency. + max_calls = 13000 + + profiled_phaseline_func = profileit(phase_lines) + + calls, text = profiled_phaseline_func(g) + if calls > max_calls: + raise Exception(f"too many function calls: {text}") + + +def test_phaselines_for_sycamore(): + g = sycamore() + start = time.time() + p = g.phase_lines() + end = time.time() + + # primary objective: correctness. + assert len(p) == 1086, len(p) + + # secondary objective: timeliness + assert end - start < 1 # second. + + # third objective: efficiency. + max_calls = 17845 + + profiled_phaseline_func = profileit(phase_lines) + + calls, text = profiled_phaseline_func(g) + if calls > max_calls: + raise Exception(f"too many function calls:\n{text}") + + t = list(g.topological_sort()) + assert t!=p + + +def test_sources(): + g = graph02() + s = g.sources(5) + e = {1, 2, 3} + assert s == e + + s2 = g.sources(1) + e2 = set() + assert s2 == e2, s2 + + s3 = g.sources(6) + e3 = {1, 2, 3, 4, 5} + assert s3 == e3 + + s4 = g.sources(7) + e4 = set() + assert s4 == e4 + + +def test_topological_sort(): + g = graph02() + outcome = [n for n in g.topological_sort()] + assert outcome == [1, 2, 7, 3, 4, 5, 6] + + outcome = [n for n in g.topological_sort(key=lambda x: -x)] + assert outcome == [7, 2, 1, 4, 3, 5, 6] + + +def test_critical_path(): + g = small_project_for_critical_path_method() + + critical_path_length, schedule = critical_path(g) + assert critical_path_length == 65 + expected_schedule = [ + Task("A", 10, 0, 0, 10, 10), + Task("B", 20, 10, 10, 30, 30), + Task("C", 5, 30, 30, 35, 35), + Task("D", 10, 35, 35, 45, 45), + Task("E", 20, 45, 45, 65, 65), + Task("F", 15, 10, 25, 25, 40), + Task("G", 5, 25, 40, 30, 45), + Task("H", 15, 10, 30, 25, 45), + ] + + for task in expected_schedule[:]: + t2 = schedule[task.task_id] + if task == t2: + expected_schedule.remove(task) + else: + print(task, t2) + raise Exception + assert expected_schedule == [] + + for tid, slack in {"F": 15, "G": 15, "H": 20}.items(): + task = schedule[tid] + assert task.slack == slack + + # Note: By introducing a fake dependency from H to F. + # the most efficient schedule is constructed, as all + # paths become critical paths, e.g. where slack is + # minimised as slack --> 0. + + g2 = critical_path_minimize_for_slack(g) + critical_path_length, schedule = critical_path(g2) + assert sum(t.slack for t in schedule.values()) == 0 + + +def test_critical_path2(): + tasks = {"A": 1, "B": 10, "C": 1, "D": 5, "E": 2, "F": 1, "G": 1, "H": 1, "I": 1} + dependencies = [ + ("A", "B"), + ("B", "C"), + ] + for letter in "DEFGHI": + dependencies.append(("A", letter)) + dependencies.append((letter, "C")) + + g = Graph() + for n, d in tasks.items(): + g.add_node(n, obj=d) + for n1, n2 in dependencies: + g.add_edge(n1, n2) + + g2 = critical_path_minimize_for_slack(g) + critical_path_length, schedule = critical_path(g2) + assert sum(t.slack for t in schedule.values()) == 0, schedule + + +def test_critical_path3(): + g = small_project_for_critical_path_method() + g.add_node("H", obj=5) # reducing duration from 15 to 5, will produce more options. + g2 = critical_path_minimize_for_slack(g) + critical_path_length, schedule = critical_path(g2) + assert critical_path_length == 65 + assert sum(t.slack for t in schedule.values()) == 30, schedule diff --git a/graph-theory/source/tests/test_traffic_scheduling_problem.py b/graph-theory/source/tests/test_traffic_scheduling_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..883a3c8e3594f1a073e9a39b348a5890fc3a4c2c --- /dev/null +++ b/graph-theory/source/tests/test_traffic_scheduling_problem.py @@ -0,0 +1,847 @@ +from time import process_time +from collections import defaultdict +from graph import Graph +from tests.test_graph import graph5x5 + +from graph.traffic_scheduling_problem import jam_solver, UnSolvable, NoSolution, Timer +from graph.traffic_scheduling_problem import State +from graph.traffic_scheduling_problem import check_user_input, path_to_moves +from graph.traffic_scheduling_problem import moves_to_synchronous_moves + + +def test_data_loading(): + """ Checks the two acceptable data formats - happy path. """ + g = Graph(from_list=[ + (1, 2, 1.0), (2, 3, 0.2), (3, 4, 0.1), (4, 5, 0.5), + (2, 7, 1.0), (2, 8, 0.5), (8, 9, 10) + ]) + + loads_as_list = [ + {'id': 1, 'start': 1, 'ends': 3}, # keyword prohibited is missing. + {'id': 2, 'start': 2, 'ends': [3, 4, 5], 'prohibited': [7, 8, 9]}, + {'id': 3, 'start': 3, 'ends': [4, 5], 'prohibited': [2]}, # gateway to off limits. + {'id': 4, 'start': 8} + ] + list_of_loads1 = list(check_user_input(g, loads_as_list).values()) + + loads_as_dict = { + 1: (1, 3), # start, end, None + 2: (2, [3, 4, 5], [7, 8, 9]), # start, end(s), prohibited + 3: (3, [4, 5], [2]), + 4: (8,) + } + list_of_loads2 = list(check_user_input(g, loads_as_dict).values()) + + assert list_of_loads1 == list_of_loads2 + + +def is_sequence_valid(sequence, graph): + """ helper to verify that the suggested path actually exists.""" + + d = defaultdict(list) + for item in sequence: + for k, t in item.items(): + if k not in d: + d[k].extend(t) + elif d[k][-1] == t[0]: + d[k].append(t[-1]) + else: + raise ValueError + + return all(graph.has_path(p) for k, p in d.items()) + + +def is_matching(a, b): + """ Helper to check that the moves in A are the same as in B.""" + g1 = Graph() + for d in a: + for k,v in d.items(): + g1.add_edge(*v, bidirectional=True) + g2 = Graph() + for d in b: + for k,v in d.items(): + g2.add_edge(*v, bidirectional=True) + return g1 == g2 + + +def test_check_concurrent_moves(): + A = [{2: (3, 4), 1: (1, 2)}, {2: (4, 1), 1: (2, 3)}] + B = [{2: (3, 2), 1: (1, 4)}, {1: (4, 3), 2: (2, 1)}] + assert is_matching(A, B) + + +def test_check_moves(): + A = [{2: (3, 4)}, {1: (1, 2)}, {2: (4, 1)}, {1: (2, 3)}] + B = [{2: (3, 2)}, {1: (1, 4)}, {1: (4, 3)}, {2: (2, 1)}] + assert is_matching(A, B) + + +def test_state_class(): + State(loads=(('A', 1), ('B', 2))) + + +def test_compact_bfs_problem(): + """ + [4]-->----+ + | | + [1]--[2]--[3] v + | | + [5]--<----+ + + find the shortest path for the collision between load on [1] and load on [2] + """ + g = Graph(from_list=[(1, 2, 1), (2, 3, 1), (4, 2, 1), (2, 5, 1), (4, 5, 3)]) + # edge 4,5 has distance 3, which is longer than path [4,2,5] which has distance 2. + + moves = jam_solver(g, loads={1: [1, 3], 2: [4, 5]}) + assert is_matching(moves, [{1: (1, 2)}, {1: (2, 3)}, {2: (4, 2)}, {2: (2, 5)}]) + + +def test_hill_climb(): + """ + [1]<--->[2]<--->[3] + \\ / + +->[4]->+ single direction! + """ + g = Graph() + for s, e in [(1, 2), (2, 3)]: + g.add_edge(s, e, 1, bidirectional=True) + for s, e in [(1, 4), (4, 3)]: + g.add_edge(s, e, 1, bidirectional=False) + + loads = {1: [1, 3], 2: [3, 1]} + moves = jam_solver(g,loads, synchronous_moves=True) + expected = [{1: (1, 4), 2: (3, 2)}, {2: (2, 1), 1: (4, 3)}] + assert is_matching(moves, expected), moves + + +def test_hill_climb_with_edge_weights(): + """ 1 1 + [1]<--->[2]<--->[3] + \ 3 1 / + <->[4]<-> + All edges are weight 1, except 1<->4 which has weight 3. + """ + g = Graph() + for sed in [(1, 2, 1), (2, 3, 1), + (1, 4, 3), # <-- 3! + (4, 3, 1)]: + g.add_edge(*sed, bidirectional=True) + + loads={1: [1, 3], 2: [3, 1]} + + moves = jam_solver(g,loads) + is_sequence_valid(moves, g) + expected = [{2: (3, 4)}, {1: (1, 2)}, {2: (4, 1)}, {1: (2, 3)}] + assert is_matching(moves, expected) + + concurrent_moves = jam_solver(g, loads, synchronous_moves=True) + expected_conc_moves = [{2: (3, 4), 1: (1, 2)}, {2: (4, 1), 1: (2, 3)}] + assert is_matching(concurrent_moves, expected_conc_moves) + + +def test_hill_climb_with_edge_different_weights(): + """ Same test as the previous, but this time edge 1<-->3 has weight 3, + whilst the rest have weight 1. + + 3 1 + [1]<--->[2]<--->[3] + \\1 1 / + <->[4]<-> + """ + g = Graph() + for sed in [(1, 2, 3), # <-- 3! + (2, 3, 1), (1, 4, 1), (4, 3, 1)]: + g.add_edge(*sed, bidirectional=True) + + loads = {1: [1, 3], 2: [3, 1]} + moves = jam_solver(g, loads) + expected_moves = [{2: (3, 4)}, {1: (1, 2)}, {2: (4, 1)}, {1: (2, 3)}] # reverse of previous test. + assert is_matching(moves, expected_moves) + + concurrent_moves = jam_solver(g, loads, synchronous_moves=True) + expected = [{2: (3, 4), 1: (1, 2)}, {2: (4, 1), 1: (2, 3)}] + assert is_matching(concurrent_moves, expected) + + +def test_hill_climb_with_restrictions(): + """ Same problem as the previous, except that all weights are 1, + and edge [1,4] and [4,3] are not bidirectional. + and the only restriction is that load 1 cannot travel over node 2. + + 1 1 + [1]<--->[2]<--->[3] + \ 1 1 / + -->[4]--> + """ + g = Graph() + for s, e in [(1, 2), (2, 3)]: + g.add_edge(s, e, 1, bidirectional=True) + for s, e in [(1, 4), (4, 3)]: + g.add_edge(s, e, 1, bidirectional=False) + + loads = {1: (1, [3], [2]), # restriction 1 cannot travel over 2 + 2: [3, 1]} + + sequence = jam_solver(g, loads) + + expected_seq = [{2: (3, 2)}, {1: (1, 4)}, {1: (4, 3)}, {2: (2, 1)}] + assert is_matching(sequence, expected_seq) + + concurrent_moves = jam_solver(g, loads, synchronous_moves=True) + expected_conc_moves = [{1: (1, 4), 2: (3, 2)},{1: (4, 3), 2: (2, 1)}] + assert is_matching(concurrent_moves, expected_conc_moves) + + +def test_hill_climb_with_restrictions_bidirectional(): + """ Same problem as the previous, except that all weights are 1, + and the only restriction is that load 1 cannot travel over node 2. + + 1 1 + [1]<--->[2]<--->[3] + \\1 1 / + <->[4]<-> + """ + g = Graph() + for s, e in [(1, 2), (2, 3), (1, 4), (4, 3)]: + g.add_edge(s, e, 1, bidirectional=True) + + loads = {1: (1, [3], [2]), # restriction 1 cannot travel over 2 + 2: (3, 1)} + + sequence = jam_solver(g, loads) + expected_seq = [{2: (3, 2)}, {1: (1, 4)}, {1: (4, 3)}, {2: (2, 1)}] + assert is_matching(sequence, expected_seq) + + concurrent_moves = jam_solver(g, loads, synchronous_moves=True) + assert concurrent_moves == [{1: (1, 4), 2: (3, 2)}, {2: (2, 1), 1: (4, 3)}] + + +def test_energy_and_restrictions_2_loads(): + """ See chart in example/images/tjs_problem_w_distance_restrictions.png + + NB: LENGTHS DIFFER FROM IMAGE! + """ + g = Graph() + for sed in [ + (1, 2, 1), + (3, 5, 2), # dead end. + (1, 3, 7), # this is the most direct route for load 2, but it is 7 long. + (3, 4, 1), (4, 6, 1), # this could be the shortest path for load 1, but + # load 1 cannot travel over 4. If it could the path [2,3,4,6] would be 3 long. + (2, 3, 1), (3, 6, 3), # this is the shortest unrestricted route for load 1: [2,3,6] and it is 4 long. + (2, 6, 8), # this is the most direct route for load 1 [2,6] but it is 8 long. + ]: + g.add_edge(*sed, bidirectional=True) + + loads = {1: (2, [6], [4]), # restriction load 1 cannot travel over 4 + 2: (3, 1)} + + moves = jam_solver(g, loads, synchronous_moves=False) + + expected= [ + {2: (3, 4)}, # distance = 1, Load2 moves out of Load1's way. + {1: (2, 3)}, # distance = 1 + {1: (3, 6)}, # distance = 3 + {2: (4, 3)}, # distance = 1, Load2 moves back onto it's starting point. + {2: (3, 2)}, # distance = 1 + {2: (2, 1)} # distance = 1 + ] # total distance = (1+3)+(1+1+1+1) = 8 + assert is_matching(moves, expected) + + +def test_energy_and_restrictions_3_loads(): + """ See chart in example/images/tjs_problem_w_distance_restrictions.png + NB: Lengths differ from image! + """ + g = Graph() + for sed in [ + + (1, 2, 1), + (3, 5, 2), # dead end. + (1, 3, 7), # this is the most direct route for load 2, but it is 7 long. + (3, 4, 1), (4, 6, 1), # this could be the shortest path for load 1, but + # load 1 cannot travel over 4. If it could the path [2,3,4,6] would be 3 long. + (2, 3, 1), (3, 6, 3), # this is the shortest unrestricted route for load 1: [2,3,6] and it is 4 long. + (2, 6, 8), # this is the most direct route for load 1 [2,6] but it is 8 long. + ]: + g.add_edge(*sed, bidirectional=True) + + loads = {1: (2, [6], [4]), + 2: (3, 1), + 3: (5, 3)} + + moves = jam_solver(g, loads, synchronous_moves=False) + assert is_sequence_valid(moves, g) + assert len(moves) == 7 + expected_moves = [ + {2: (3, 4)}, # distance 1 + {1: (2, 3)}, # distance 1 + {1: (3, 6)}, # distance 3 + {2: (4, 3)}, # distance 1 + {2: (3, 2)}, # distance 1 + {2: (2, 1)}, # distance 1 + {3: (5, 3)} # distance 2 + ] # total distance = (1+3)+(1+1+1+1)+(2) = 10 + assert is_matching(moves, expected_moves), moves + + +def test_energy_and_restrictions_3_loads_b(): + """ See chart in example/images/tjs_problem_w_distance_restrictions.png + NB: Lengths differ from image! + """ + g = Graph() + for sed in [ + (1, 2, 1), + (3, 5, 2), # dead end. + (1, 3, 7), # this is the most direct route for load 2, but it is 7 long. + (3, 4, 1), (4, 6, 1), # this could be the shortest path for load 1, but + # load 1 cannot travel over 4. If it could the path [2,3,4,6] would be 3 long. + (2, 3, 1), (3, 6, 3), # this is the shortest unrestricted route for load 1: [2,3,6] and it is 4 long. + (2, 6, 8), # this is the most direct route for load 1 [2,6] but it is 8 long. + ]: + g.add_edge(*sed, bidirectional=True) + + loads = {1: (2, [6], [4]), + 2: (3, 1), + 3: (4, 3)} # Load 3 blocks load two from moving in here. + + moves = jam_solver(g, loads, synchronous_moves=False) + atomic_moves = [ + {1: (2, 6)}, # 8 + {2: (3, 2)}, # 1 + {2: (2, 1)}, # 1 + {3: (4, 3)} # 1 + ] # total distance 11 + + assert is_matching(moves, atomic_moves) + # if load 2 would move to 5, the extra cost is 4, but load 1 could travel via [2,3,6] at cost 4. + # However the distance LEFT for load 2 would be longer, whereby it is the lesser preferred solution. + + +def test_energy_and_restrictions_3_loads_c(): + """ See chart in example/images/tjs_problem_w_distance_restrictions.png + NB: Lengths differ from image! + """ + g = Graph() + for sed in [ + (1, 2, 1), + (3, 5, 1), # dead end. + (1, 3, 7), # this is the most direct route for load 2, but it is 7 long. + (3, 4, 1), (4, 6, 1), # this could be the shortest path for load 1, but + # load 1 cannot travel over 4. If it could the path [2,3,4,6] would be 3 long. + (2, 3, 1), (3, 6, 3), # this is the shortest unrestricted route for load 1: [2,3,6] and it is 4 long. + (2, 6, 8), # this is the most direct route for load 1 [2,6] but it is 8 long. + ]: + g.add_edge(*sed, bidirectional=True) + + loads = {1: (2, [6], [4]), + 2: (3, 1), + 3: (4, 3)} # Load 3 blocks load two from moving in here. + + moves = jam_solver(g, loads, synchronous_moves=False) + + expected = [ + {2: (3, 5)}, # load 2 moves out of the way at cost 1 + {1: (2, 3)}, {1: (3, 6)}, # load 1 takes shortest permitted path. + {2: (5, 3)}, {2: (3, 2)}, {2: (2, 1)}, # load 2 moves to destination. + {3: (4, 3)} # load 3 moves to destination. + ] # total distance 9 + assert is_matching(moves, expected), moves + + +def test_energy_and_restrictions_2_load_high_detour_costs(): + """ See chart in example/images/tjs_problem_w_distance_restrictions.png """ + g = Graph() + for sed in [ + (1, 2, 1), + (1, 3, 70), # this is the most direct route for load 2, but it is 70 long. + (3, 5, 2), # 5 is a dead end at higher cost than going (3,4) + (3, 4, 1), (4, 6, 1), # this could be shortest path for load 1, but + # load 1 cannot travel over 4. If it could the path [2,3,4,6] would be 3 long. + (2, 3, 1), (3, 6, 3), # this is the shortest unrestricted route for load 1: [2,3,6] and it is 4 long. + (2, 6, 50), # this is the most direct route for load 1 [2,6] but it is 50 long. + ]: + g.add_edge(*sed, bidirectional=True) + + loads = {"A": (2, [6], [4]), + "B": (3, 1)} + + moves = jam_solver(g, loads, synchronous_moves=False, return_on_first=False) + assert is_sequence_valid(moves, g) + assert len(moves) == 6 + expected = [ + {"B": (3, 4)}, # 2 moves into the dead end. + {"A": (2, 3)}, # 1 moves into where 2 was. + {"A": (3, 6)}, # 1 moves onto destination. + {"B": (4, 3)}, # 2 moves back to origin along path [4,3,2,1] + {"B": (3, 2)}, + {"B": (2, 1)} + ] + assert is_matching(moves, expected), moves + + +def test_simple_reroute(): + """ to loads on a collision path. """ + g = Graph() + for s, e in [(1, 2), (2, 3)]: + g.add_edge(s, e, 1, bidirectional=True) + for s, e in [(1, 4), (4, 3)]: + g.add_edge(s, e, 1, bidirectional=False) + + loads = {1: [1, 3], 2: [3, 1]} + + concurrent_moves = jam_solver(g, loads, synchronous_moves=True) + expected = [{1: (1, 4), 2: (3, 2)}, {1: (4, 3), 2: (2, 1)}] + assert is_matching(concurrent_moves, expected), concurrent_moves + + +def test_simple_reroute_2(): + """ to loads on a collision path. + + [1]<-->[2]<-->[3]<-->[4] + | ^ + +---->[5]-->[6]------+ + """ + g = Graph() + for s, e in [(1, 2), (2, 3), (3, 4)]: + g.add_edge(s, e, 1, bidirectional=True) + for s, e in [(1, 5), (5, 6), (6, 4)]: + g.add_edge(s, e, 1, bidirectional=False) + + loads = {1: [1, 4], 2: [4, 1]} + + sequence = jam_solver(g, loads, synchronous_moves=False) + + atomic_sequence = [{1: (1, 5)}, {1: (5, 6)}, {2: (4, 3)}, {1: (6, 4)}, {2: (3, 2)}, {2: (2, 1)}] + assert is_matching(sequence, atomic_sequence) + assert is_sequence_valid(sequence, g) + + +def test_simple_reroute_3(): + """ Loop with 6 nodes: + 1 <--> 2 <--> 3 <--> 4 <-- 5 <--> 6 <--> (1) + """ + g = Graph() + edges = [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 1)] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + g.del_edge(4, 5) + + loads = {1: [1, 3], 2: [3, 1]} + + sequence = jam_solver(g, loads, synchronous_moves=False) + + expected = [{1: (1, 6)}, {1: (6, 5)}, {1: (5, 4)}, {2: (3, 2)}, {1: (4, 3)}, {2: (2, 1)}] + assert is_matching(sequence, expected) + assert is_sequence_valid(sequence, g) + + +def test_shuffle(): + g = Graph() + edges = [(1, 2), (2, 3), (3, 5), (3, 6), (5, 6), (6, 7), (7, 8)] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + + loads = { + 1: (1, 7), + 2: (2, [2, 5]), + 3: (8, [8, 5]) + } + sequence = jam_solver(g, loads, synchronous_moves=False) + + expected = [ + {2: (2, 3)}, + {2: (3, 5)}, + {1: (1, 2)}, + {1: (2, 3)}, + {1: (3, 6)}, + {1: (6, 7)}] + + assert is_matching(sequence, expected), sequence + + +def test_shuffle2(): + g = Graph() + edges = [(1, 2), (2, 3), (3, 5), (3, 6), (5, 6), (6, 7), (7, 8)] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + loads = { + 1: (1, 7), + 2: (2, g.nodes()), + 3: (8, g.nodes()) + } + + sequence = jam_solver(g, loads, synchronous_moves=False, return_on_first=True) + + expected = [ + {2: (2, 3)}, + {2: (3, 5)}, + {1: (1, 2)}, + {1: (2, 3)}, + {1: (3, 6)}, + {1: (6, 7)}] + + assert is_matching(sequence, expected), sequence + + +def test_simple_reroute_4(): + """ + 1 + / \\ + 6---2 + / \\/ \\ + 5 - 4 - 3 + """ + g = Graph() + edges = [(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 1), (2, 6), (2, 4), (6, 2)] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + g.del_edge(4, 5) + + loads = {1: [1, 4], + 3: [3, 1], + 6: [6, 2]} + + sequence = jam_solver(g, loads, synchronous_moves=False) + assert sequence == [{1: (1, 2)}, {1: (2, 4)}, {3: (3, 2)}, {3: (2, 1)}, {6: (6, 2)}] + + g.del_edge(2, 4) + + sequence = jam_solver(g, loads, synchronous_moves=False) + + expected = [{1: (1, 2)}, {3: (3, 4)}, {1: (2, 3)}, {3: (4, 2)}, {3: (2, 1)}, {6: (6, 2)}, {1: (3, 4)}] + assert is_matching(sequence, expected) + + +def test_clockwise_rotation(): + """ A simple loop of 4 locations, where 3 loads need to move + clockwise. """ + g = Graph() + edges = [(1, 2), (2, 3), (3, 4), (4, 1), ] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + + loads = {1: [1, 2], 2: [2, 3], 3: [3, 4]} # position 4 is empty. + + sequence = jam_solver(g, loads, synchronous_moves=False) + + expected = [{3: (3, 4)}, # first move. + {2: (2, 3)}, # second move. + {1: (1, 2)}] # last move. + assert is_matching(sequence, expected), sequence + + +def test_small_gridlock(): + """ a grid lock is given, solver solves it.""" + g = Graph() + edges = [ + (1, 2), (1, 4), (2, 3), (2, 5), (3, 6), (4, 5), (5, 6), (4, 7), (5, 8), (6, 9), (7, 8), (8, 9) + ] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + + loads = {'a': [2, 1], 'b': [5, 2], 'c': [4, 3], 'd': [8], 'e': [1, 9]} + + results = [] + + # TRIAL - 1 + start = process_time() + moves = jam_solver(g, loads) + e = process_time() - start + concurrent = jam_solver(g, loads, synchronous_moves=True) + d = sum(len(d) for d in moves) + results.append((e, d, len(concurrent))) + + assert d == 11, d + expected = [{'b': (5, 6), 'c': (4, 5), 'e': (1, 4)}, + {'b': (6, 3), 'c': (5, 6), 'e': (4, 5), 'a': (2, 1)}, + {'b': (3, 2), 'c': (6, 3), 'e': (5, 6)}, + {'e': (6, 9)}] + assert all(m in expected for m in moves), moves + + assert len(concurrent) == 4 + + # TRIAL - 2 + start = process_time() + moves = jam_solver(g, loads) + e = process_time() - start + concurrent = jam_solver(g, loads, synchronous_moves=True) + d = sum(len(d) for d in moves) + results.append((e, d, len(concurrent))) + + for e, d, c in results: + print("duration:", round(e, 4), "| distance", d, "| concurrent moves", c) + results.clear() + + +def test_snake_gridlock(): + """ + A bad route was given to train abcd, and now the train has gridlocked itself. + + 9 - 10 - 11 - 12 + | + 1 - 2 - 3 - 4 - 5d-> 6c + ^ | + | v + 8a - 7b + + :return: + """ + g = Graph() + edges = [(a, b) for a, b in zip(range(1, 12), range(2, 13)) if (a, b) != (8, 9)] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + g.add_edge(8, 5, 1, bidirectional=True) + g.add_edge(5, 9, 1, bidirectional=True) + + loads = {'a': [8, 12], 'b': [7, 11], 'c': [6, 10], 'd': [5, 9]} + sequence = jam_solver(g, loads, synchronous_moves=False, return_on_first=False) + + sync_moves = moves_to_synchronous_moves(sequence, check_user_input(g, loads)) + + expected = [{'d': (5, 4)}, # d goes one step back. + {'a': (8, 5)}, # a moves forward towards its destination. + {'b': (7, 8)}, # b moves forward to it's destination. + {'a': (5, 9)}, + {'b': (8, 5)}, + {'a': (9, 10)}, + {'b': (5, 9)}, + {'c': (6, 5)}, # c moves forward. + {'a': (10, 11)}, + {'b': (9, 10)}, + {'c': (5, 9)}, + {'d': (4, 5)}, + {'a': (11, 12)}, + {'b': (10, 11)}, + {'c': (9, 10)}, + {'d': (5, 9)}] # d does a left turn (shortcut). + assert is_matching(sequence, expected) + + expected = [{'d': (5, 4), 'a': (8, 5), 'b': (7, 8)}, + {'a': (5, 9), 'b': (8, 5)}, + {'a': (9, 10), 'b': (5, 9), 'c': (6, 5)}, + {'a': (10, 11), 'b': (9, 10), 'c': (5, 9), 'd': (4, 5)}, + {'a': (11, 12), 'b': (10, 11), 'c': (9, 10), 'd': (5, 9)}] + assert is_matching(expected, sync_moves), sync_moves + + +def test_5x5_graph(): + g = graph5x5() + loads = {'a': [6], 'b': [11, 1], 'c': [16, 2], 'd': [17, 4], 'e': [19, 5], 'f': [20, 3]} + + sequence = jam_solver(g, loads, return_on_first=True, timeout=30_000) + assert is_sequence_valid(sequence, g) + + +def test_2_trains(): + """ + two trains of loads are approaching each other. + train 123 going from 1 to 14 + train 4567 going from 14 to 1. + + At intersection 4 train 123 can be broken apart and + buffered, so that train 4567 can pass. + + The reverse (buffering train 4567) is not possible. + + [1]--[2]--[3]--[4]--[5]--[9]--[10]--[11]--[12]--[13]--[14] + +---[6]---+ + +---[7]---+ + +---[8]---+ + """ + g = Graph() + edges = [ + (1, 2), + (2, 3), + (3, 4), + (4, 5), (4, 6), (4, 7), (4, 8), + (5, 9), (6, 9), (7, 9), (8, 9), + (9, 10), + (10, 11), + (11, 12), + (12, 13), + (13, 14), + ] + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + + loads = { + 41: [1, 12], + 42: [2, 13], + 43: [3, 14], + 44: [11, 1], + 45: [12, 2], + 46: [13, 3], + 47: [14, 4], + } + + sequence = jam_solver(g, loads, return_on_first=True, timeout=180_000) + assert is_sequence_valid(sequence, g) + expected = [{43: (3, 4)}, {43: (4, 6)}, {42: (2, 3)}, {42: (3, 4)}, {42: (4, 7)}, {41: (1, 2)}, + {41: (2, 3)}, {41: (3, 4)}, {41: (4, 5)}, {44: (11, 10)}, {44: (10, 9)}, {44: (9, 8)}, + {44: (8, 4)}, {44: (4, 3)}, {44: (3, 2)}, {44: (2, 1)}, {45: (12, 11)}, {45: (11, 10)}, + {45: (10, 9)}, {45: (9, 8)}, {45: (8, 4)}, {45: (4, 3)}, {45: (3, 2)}, {46: (13, 12)}, + {46: (12, 11)}, {46: (11, 10)}, {46: (10, 9)}, {46: (9, 8)}, {46: (8, 4)}, {46: (4, 3)}, + {47: (14, 13)}, {47: (13, 12)}, {47: (12, 11)}, {47: (11, 10)}, {47: (10, 9)}, {47: (9, 8)}, + {47: (8, 4)}, {43: (6, 9)}, {43: (9, 10)}, {43: (10, 11)}, {43: (11, 12)}, {43: (12, 13)}, + {43: (13, 14)}, {42: (7, 9)}, {42: (9, 10)}, {42: (10, 11)}, {42: (11, 12)}, {42: (12, 13)}, + {41: (5, 9)}, {41: (9, 10)}, {41: (10, 11)}, {41: (11, 12)}] + assert is_matching(expected, sequence), sequence + + +def test_3_trains(): + """ + Two trains (abc & d) are going east. One train is going west (efgh). + + a-b-c--0-0-0--d--0--e-f-g-h + \\--0---/ \\0-/ + + 1-2-3--4-5-6--7--8---9-10-11-12 + \\--13--/ \\14-/ + + The solution is given by side stepping abc (on 4,5,6) & d (on 8) + and letting efgh pass on (12, 11, 10, 9, 14, 7, 13, 3, 2, 1) + """ + g = Graph() + edges = [ + (3, 13), (13, 7), (7, 14), (14, 9) + ] + for a, b in zip(range(1, 12), range(2, 13)): + edges.append((a, b)) + for s, e in edges: + g.add_edge(s, e, 1, bidirectional=True) + + loads = { + 'a': [1, 10], 'b': [2, 11], 'c': [3, 12], 'd': [8, 9], # east bound + 'e': [9, 1], 'f': [10, 2], 'g': [11, 3], 'h': [12, 4] # west bound + } + + sequence = jam_solver(g, loads, return_on_first=True,timeout=40_000) + assert sequence is not None + + +def test_loop_9(): + g = Graph( + from_list=[(a, b, 1) for a, b in zip(range(1, 8), range(2, 9))] + [(8, 1, 1)] + ) + loads = {1: [1, 2], 2: [3, 4], 3: [5, 6], 4: [7, 8]} + solution = jam_solver(g, loads, return_on_first=True) + + assert is_sequence_valid(solution, g) + expected = [{4: (7, 8), 3: (5, 6), 2: (3, 4), 1: (1, 2)}] + assert solution == expected + + sync_moves = jam_solver(g, loads, return_on_first=True, synchronous_moves=True) + assert sync_moves == [{4: (7, 8), 3: (5, 6), 2: (3, 4), 1: (1, 2)}] + + +def test_loop_52(): + g = Graph( + from_list=[ + (52, 1, 1), (1, 2, 1), (2, 3, 1), (3, 4, 1), (4, 5, 1), (5, 6, 1), (6, 7, 1), (7, 8, 1), (8, 9, 1), + (9, 10, 1), (10, 11, 1), (11, 12, 1), (12, 13, 1), (13, 14, 1), (14, 15, 1), (15, 16, 1), (16, 17, 1), + (17, 18, 1), (18, 19, 1), (19, 20, 1), (20, 21, 1), (21, 22, 1), (22, 23, 1), (23, 24, 1), (24, 25, 1), + (25, 26, 1), (26, 27, 1), (27, 28, 1), (28, 29, 1), (29, 30, 1), (30, 31, 1), (31, 32, 1), (32, 33, 1), + (33, 34, 1), (34, 35, 1), (35, 36, 1), (36, 37, 1), (37, 38, 1), (38, 39, 1), (39, 40, 1), (40, 41, 1), + (41, 42, 1), (42, 43, 1), (43, 44, 1), (44, 45, 1), (45, 46, 1), (46, 47, 1), (47, 48, 1), (48, 49, 1), + (49, 50, 1), (50, 51, 1), (51, 52, 1) + ] + ) + + loads = { + 98: [52, 1], 55: [2, 3], 56: [3, 4], 57: [4, 5], 58: [5, 6], 59: [6, 7], 60: [7, 8], 61: [9, 10], 62: [10, 11], + 63: [11, 12], 64: [12, 13], 65: [14, 15], 66: [15, 16], 67: [16, 17], 68: [17, 18], 69: [18, 19], 70: [19, 20], + 71: [21, 22], 72: [22, 23], 73: [23, 24], 74: [24, 25], 75: [25, 26], 76: [26, 27], 77: [28, 29], 78: [29, 30], + 79: [30, 31], 80: [31, 32], 81: [32, 33], 82: [33, 34], 83: [35, 36], 84: [36, 37], 85: [37, 38], 86: [38, 39], + 87: [39, 40], 88: [40, 41], 89: [42, 43], 90: [43, 44], 91: [44, 45], 92: [45, 46], 93: [46, 47], + 94: [47, 48], 95: [49, 50], 96: [50, 51], 97: [51, 52] + } + + solution = jam_solver(g, loads, return_on_first=True, timeout=1_000) + assert is_sequence_valid(solution, g) + + loads2 = check_user_input(g, loads) + concurrent_moves = moves_to_synchronous_moves(solution, loads2) + assert concurrent_moves == [ + {98: (52, 1), 60: (7, 8), 59: (6, 7), 58: (5, 6), 57: (4, 5), 56: (3, 4), 55: (2, 3), 64: (12, 13), + 63: (11, 12), 62: (10, 11), 61: (9, 10), 70: (19, 20), 69: (18, 19), 68: (17, 18), 67: (16, 17), 66: (15, 16), + 65: (14, 15), 76: (26, 27), 75: (25, 26), 74: (24, 25), 73: (23, 24), 72: (22, 23), 71: (21, 22), 82: (33, 34), + 81: (32, 33), 80: (31, 32), 79: (30, 31), 78: (29, 30), 77: (28, 29), 88: (40, 41), 87: (39, 40), 86: (38, 39), + 85: (37, 38), 84: (36, 37), 83: (35, 36), 94: (47, 48), 93: (46, 47), 92: (45, 46), 91: (44, 45), 90: (43, 44), + 89: (42, 43), 97: (51, 52), 96: (50, 51), 95: (49, 50)} + ], "something is wrong. All moves CAN happen at the same time." + + +def test_simple_failed_path(): + """ two colliding loads with no solution """ + g = Graph() + for s, e in [(1, 2), (2, 3)]: + g.add_edge(s, e, 1, bidirectional=True) + + loads = {1: [1, 3], 2: [3, 1]} + + try: + _ = jam_solver(g, loads, return_on_first=True, timeout=200) + assert False, "The problem is unsolvable." + except NoSolution: + assert True + + +def test_incomplete_graph(): + """ two loads with an incomplete graph making the problem unsolvable """ + g = Graph() + for s, e in [(1, 2), (2, 3)]: + g.add_edge(s, e, 1, bidirectional=True) + g.add_node(5) + + loads = {1: [1, 5], 2: [5, 1]} + + try: + _ = jam_solver(g, loads, timeout=200) + assert False, "There is no path." + except UnSolvable as e: + assert str(e) == 'load 1 has no path from 1 to 5' + +def test_timeout(): + """ Timeout prevents all end states from being recorded, ensure that a solution is still found """ + edges = {1: {2: 1, 41: 2, 63: 2}, + 41: {42: 1, 1: 2, 63: 2}, + 65: {1: 2, 41: 2, 63: 2}, + 2: {1: 1, 3: 1}, + 3: {2: 1, 4: 1}, + 4: {3: 1, 5: 1}, + 5: {4: 1}, + 42: {41: 1, 43: 1}, + 43: {42: 1, 44: 1}, + 44: {43: 1, 45: 1}, + 45: {44: 1}, + 63: {'pseudo_L48': 1, 'pseudo_L33': 1, 'pseudo_L35': 1, 'pseudo_L55': 1}} + + subgraph_2 = Graph(from_dict=edges) + + loads_for_jam_solver = {'L23': (41, [3, 4, 41, 44, 1, 2]), + 'L48': (42, ['pseudo_L48']), + 'L33': (43, ['pseudo_L33']), + 'L8': (44, [3, 4, 41, 44, 1, 2]), + 'L35': (45, ['pseudo_L35']), + 'L5': (3, [3, 4, 41, 44, 1, 2]), + 'L15': (4, [3, 4, 41, 44, 1, 2]), + 'L55': (5, ['pseudo_L55'])} + + moves = jam_solver(graph=subgraph_2, loads=loads_for_jam_solver, timeout=5000, synchronous_moves=False) + + expected_moves = [{'L23': (41, 1)}, {'L48': (42, 41)}, {'L48': (41, 63)}, {'L48': (63, 'pseudo_L48')}, + {'L33': (43, 42)}, {'L33': (42, 41)}, {'L33': (41, 63)}, {'L33': (63, 'pseudo_L33')}, + {'L5': (3, 2)}, {'L15': (4, 3)}, {'L55': (5, 4)}, {'L23': (1, 41)}, {'L5': (2, 1)}, + {'L15': (3, 2)}, {'L55': (4, 3)}, {'L23': (41, 42)}, {'L23': (42, 43)}, {'L5': (1, 41)}, + {'L15': (2, 1)}, {'L55': (3, 2)}, {'L5': (41, 42)}, {'L15': (1, 41)}, {'L55': (2, 1)}, + {'L55': (1, 63)}, {'L55': (63, 'pseudo_L55')}, {'L15': (41, 1)}, {'L5': (42, 41)}, + {'L23': (43, 42)}, {'L15': (1, 2)}, {'L5': (41, 1)}, {'L23': (42, 41)}, {'L8': (44, 43)}, + {'L35': (45, 44)}, {'L8': (43, 42)}, {'L35': (44, 43)}, {'L15': (2, 3)}, {'L5': (1, 2)}, + {'L15': (3, 4)}, {'L5': (2, 3)}, {'L23': (41, 1)}, {'L23': (1, 2)}, {'L8': (42, 41)}, + {'L35': (43, 42)}, {'L8': (41, 1)}, {'L35': (42, 41)}, {'L35': (41, 63)}, + {'L35': (63, 'pseudo_L35')}] + + for index in range(5): + assert moves[index] == expected_moves[index] diff --git a/graph-theory/source/tests/test_transform.py b/graph-theory/source/tests/test_transform.py new file mode 100644 index 0000000000000000000000000000000000000000..3d799d8c889e30b8f34f284ccdf53ae57339980c --- /dev/null +++ b/graph-theory/source/tests/test_transform.py @@ -0,0 +1,27 @@ +from graph import Graph +from tests.test_graph import graph3x3, graph03 + + +def test_adjacency_matrix(): + g = graph3x3() + am = g.adjacency_matrix() + g2 = Graph(from_dict=am) + assert g.is_subgraph(g2) + assert not g2.is_subgraph(g) + + +def test_all_pairs_shortest_path(): + g = graph03() + d = g.all_pairs_shortest_paths() + g2 = Graph(from_dict=d) + for n1 in g.nodes(): + for n2 in g.nodes(): + if n1 == n2: + continue + d, path = g.shortest_path(n1, n2) + d2 = g2.edge(n1, n2) + assert d == d2 + + g2.add_node(100) + d = g2.all_pairs_shortest_paths() + # should trigger print of isolated node. \ No newline at end of file diff --git a/graph-theory/source/tests/test_transshipment_problem.py b/graph-theory/source/tests/test_transshipment_problem.py new file mode 100644 index 0000000000000000000000000000000000000000..ff618bc4ad099ca9db3af18e1d49fb31da4b235d --- /dev/null +++ b/graph-theory/source/tests/test_transshipment_problem.py @@ -0,0 +1,127 @@ +from graph import Graph +from graph.transshipment_problem import clondike_transshipment_problem, Train, schedule_rail_system + + +def test_mining_train(): + """ + Assures that a train can schedule a number of in, out and in/out jobs + using TSP. + """ + g = clondike_transshipment_problem() + assert isinstance(g, Graph) + + equipment_deliveries = [ + ("L-1", "L-1-1"), + ("L-1", "L-1-2"), # origin, destination + ("L-1", "L-1-3"), + ("L-1", "L-1-4") + ] + + mineral_deliveries = [ + ("L-1-1", "L-1"), + ("L-1-2", "L-1"), + ("L-1-3", "L-1"), + ("L-1-4", "L-1"), + ] + + access_nodes = {"L-1", "L-1-1", "L-1-2", "L-1-3", "L-1-4"} + + train = Train(rail_network=g, start_location="L-1", access=access_nodes) + + s1 = train.schedule(equipment_deliveries) + s2 = train.schedule(mineral_deliveries) + s3 = train.schedule(equipment_deliveries[:] + mineral_deliveries[:]) + + s1_expected = [ + ('L-1', 'L-1-1'), ('L-1', 'L-1-2'), ('L-1', 'L-1-3'), ('L-1', 'L-1-4') + ] # shortest jobs first.! + + s2_expected = [ + ('L-1-1', 'L-1'), ('L-1-2', 'L-1'), ('L-1-3', 'L-1'), ('L-1-4', 'L-1') + ] # shortest job first! + + s3_expected = [ + ('L-1', 'L-1-1'), ('L-1-1', 'L-1'), # circuit 1 + ('L-1', 'L-1-2'), ('L-1-2', 'L-1'), # circuit 2 + ('L-1', 'L-1-3'), ('L-1-3', 'L-1'), # circuit 3 + ('L-1', 'L-1-4'), ('L-1-4', 'L-1') # circuit 4 + ] # shortest circuit first. + + assert s1 == s1_expected + assert s2 == s2_expected + assert s3 == s3_expected + + +def test_surface_mining_equipment_delivery(): + """ + Assures that equipment from the surface can arrive in the mine + """ + g = clondike_transshipment_problem() + + equipment_deliveries = [ + ("Surface", "L-1-1"), + ("Surface", "L-1-2"), # origin, destination + ] + + lift_access = {"Surface", "L-1", "L-2"} + lift = Train(rail_network=g, start_location="Surface", access=lift_access) + + L1_access = {"L-1", "L-1-1", "L-1-2", "L-1-3", "L-1-4"} + level_1_train = Train(rail_network=g, start_location="L-1", access=L1_access) + + assert lift_access.intersection(L1_access), "routing not possible!" + + schedule_rail_system(rail_network=g, trains=[lift, level_1_train], + jobs=equipment_deliveries) + s1 = level_1_train.schedule() + s2 = lift.schedule() + + s1_expected = [('L-1', 'L-1-1'), ('L-1', 'L-1-2')] + s2_expected = [("Surface", "L-1"), ("Surface", "L-1")] + + assert s1 == s1_expected + assert s2 == s2_expected + + +def test_double_direction_delivery(): + """ + Tests a double delivery schedule: + Lift is delivering equipment into the mine as Job-1, Job-2 + Train is delivering gold out of the mine as Job-3, Job-4 + The schedules are thereby: + Lift: [Job-1][go back][Job-2] + Train: [Job-3][go back][Job-4] + The combined schedule should thereby be: + Lift: [Job-1][Job-3][Job-2][Job-4] + Train: [Job-3][Job-1][Job-4][Job-2] + which yields zero idle runs. + """ + g = clondike_transshipment_problem() + + equipment_deliveries = [ + ("Surface", "L-1-1"), + ("Surface", "L-1-2") + ] + + mineral_deliveries = [ + ("L-1-1", "Surface"), + ("L-1-2", "Surface") + ] + lift_access = {"Surface", "L-1", "L-2"} + lift = Train(rail_network=g, start_location="Surface", access=lift_access) + + L1_access = {"L-1", "L-1-1", "L-1-2", "L-1-3", "L-1-4"} + level_1_train = Train(rail_network=g, start_location="L-1", access=L1_access) + + assert lift_access.intersection(L1_access), "routing not possible!" + + schedule_rail_system(rail_network=g, trains=[lift, level_1_train], + jobs=equipment_deliveries + mineral_deliveries) + s1 = level_1_train.schedule() + s2 = lift.schedule() + + s1_expected = [('L-1', 'L-1-1'), ('L-1-1', 'L-1'), ('L-1', 'L-1-2'), ('L-1-2', 'L-1')] + s2_expected = [('Surface', 'L-1'), ('L-1', 'Surface'), ('Surface', 'L-1'), ('L-1', 'Surface')] + + assert s1 == s1_expected + assert s2 == s2_expected diff --git a/graph-theory/source/tests/test_tsp.py b/graph-theory/source/tests/test_tsp.py new file mode 100644 index 0000000000000000000000000000000000000000..003b4e979be0bbb5b099e5e2596af676cf84e834 --- /dev/null +++ b/graph-theory/source/tests/test_tsp.py @@ -0,0 +1,264 @@ +import math +import itertools + +from bisect import insort + +from graph import Graph, same_path +from graph.random import random_xy_graph +from tests import test_graph + + +def lec_24_graph(): + """Sample from https://www.youtube.com/watch?v=-cLsEHP0qt0 + + Lecture series on Advanced Operations Research by + Prof. G.Srinivasan, Department of Management Studies, IIT Madras. + For more details on NPTEL visit http://nptel.iitm.ac.in + + """ + return Graph( + from_list=[ + (1, 2, 10), + (1, 3, 8), + (1, 4, 9), + (1, 5, 7), + (2, 1, 10), + (2, 3, 10), + (2, 4, 5), + (2, 5, 6), + (3, 1, 8), + (3, 2, 10), + (3, 4, 8), + (3, 5, 9), + (4, 1, 9), + (4, 2, 5), + (4, 3, 8), + (4, 5, 6), + (5, 1, 7), + (5, 2, 6), + (5, 3, 9), + (5, 4, 6), + ] + ) + + +def lec_24_brute_force(): + """Generates all combinations of solutions""" + g = lec_24_graph() + L = [] + shortest_tour = float("inf") + for tour in itertools.permutations(g.nodes(), len(g.nodes())): + d = g.distance_from_path(tour + (tour[0],)) + if d <= shortest_tour: + insort(L, (d, tour)) # solutions are inserted by ascending distance. + shortest_tour = d + + solutions = set() + p1 = L[0][1] # first solution == shortest tour. + for d, t in L: + if d == shortest_tour: + t_reverse = tuple(list(t)[::-1]) + if any( + [ + g.same_path(t, p1), # same path just offset in sequence. + g.same_path(t_reverse, p1), + ] # same path reversed. + ): + solutions.add(t) + else: + raise AssertionError + return solutions + + +lec_24_tsp_path = [1, 3, 4, 2, 5] +lec_24_valid_solutions = lec_24_brute_force() +assert tuple(lec_24_tsp_path) in lec_24_valid_solutions + + +def test_greedy(): + g = lec_24_graph() + d, tour = g.solve_tsp(method="greedy") + assert tuple(tour) in lec_24_valid_solutions + assert g.same_path(tour, lec_24_tsp_path) + + +def test_branch_and_bound(): + g = lec_24_graph() + d, tour = g.solve_tsp(method="bnb") + assert d == 34 + assert tuple(tour) in lec_24_valid_solutions + + +def test_bnb(): + g = Graph( + from_list=[ + ((755, 53), (282, 126), 478.60004178854814), + ((755, 53), (559, 45), 196.16319736382766), + ((755, 53), (693, 380), 332.8257802514703), + ((755, 53), (26, 380), 798.9806005154318), + ((755, 53), (229, 72), 526.3430440311718), + ((755, 53), (655, 58), 100.12492197250393), + ((282, 126), (559, 45), 288.60006930006097), + ((282, 126), (655, 58), 379.14772846477666), + ((282, 126), (229, 72), 75.66372975210778), + ((282, 126), (755, 53), 478.60004178854814), + ((282, 126), (26, 380), 360.6272313622475), + ((282, 126), (693, 380), 483.15318481823135), + ((655, 58), (559, 45), 96.87620966986684), + ((655, 58), (26, 380), 706.6293229126569), + ((655, 58), (693, 380), 324.2344830520036), + ((655, 58), (755, 53), 100.12492197250393), + ((655, 58), (282, 126), 379.14772846477666), + ((655, 58), (229, 72), 426.2299848673249), + ((559, 45), (26, 380), 629.5347488423495), + ((559, 45), (655, 58), 96.87620966986684), + ((559, 45), (693, 380), 360.8060420780118), + ((559, 45), (755, 53), 196.16319736382766), + ((559, 45), (229, 72), 331.1027030998086), + ((559, 45), (282, 126), 288.60006930006097), + ((26, 380), (229, 72), 368.8807395351511), + ((26, 380), (693, 380), 667.0), + ((26, 380), (655, 58), 706.6293229126569), + ((26, 380), (282, 126), 360.6272313622475), + ((26, 380), (755, 53), 798.9806005154318), + ((26, 380), (559, 45), 629.5347488423495), + ((229, 72), (693, 380), 556.9201019895044), + ((229, 72), (755, 53), 526.3430440311718), + ((229, 72), (655, 58), 426.2299848673249), + ((229, 72), (559, 45), 331.1027030998086), + ((229, 72), (26, 380), 368.8807395351511), + ((229, 72), (282, 126), 75.66372975210778), + ((693, 380), (755, 53), 332.8257802514703), + ((693, 380), (229, 72), 556.9201019895044), + ((693, 380), (282, 126), 483.15318481823135), + ((693, 380), (26, 380), 667.0), + ((693, 380), (559, 45), 360.8060420780118), + ((693, 380), (655, 58), 324.2344830520036), + ] + ) + d1, tour1 = g.solve_tsp("bnb") + d2, tour2 = g.solve_tsp("greedy") + assert d1 == d2 + + +def simplify(graph): + """helper that simplifies the xy to mere node ids.""" + d = {} + cnt = itertools.count(1) + c2 = [] + for s, e, dst in graph.edges(): + if s not in d: + d[s] = next(cnt) + if e not in d: + d[e] = next(cnt) + c2.append((d[s], d[e], dst)) + + g = Graph(from_list=c2) + return g + + +def test_random_graph_3_bnb(): + from random import seed, randint + + for i in range(4, 12): + s = randint(1, int(1e7)) + seed(s) + g = random_xy_graph(i, x_max=800, y_max=400) # a fully connected graph. + g = simplify(g) + d1, t1 = g.solve_tsp("bnb") + d2, t2 = g.solve_tsp("greedy") + assert d1 <= d2 or math.isclose(d1, d2), (d1, d2, g.edges()) + print(i, s, "|", round(100 * ((d2 - d1) / d1)), "% greedy dist excess rel to bnb dist") + + +def test_random_graph_4_bnb(): + # fmt:off + c = [(1, 2, 467.8226159560908), (1, 3, 561.6021723604708), (1, 4, 138.88484438555562), (1, 5, 661.6358515074587), (1, 6, 654.3951405687545), (1, 7, 114.82595525402782), (1, 8, 276.99097458220547), (1, 9, 519.7172308092161), (1, 10, 186.52613757862463), (1, 11, 205.08047201037937), (2, 3, 96.87620966986684), (2, 10, 288.60006930006097), (2, 6, 360.8060420780118), (2, 1, 467.8226159560908), (2, 11, 384.9623358200124), (2, 4, 331.1027030998086), (2, 7, 526.7988230814492), (2, 8, 629.5347488423495), (2, 5, 196.16319736382766), (2, 9, 178.04493814764857), (3, 4, 426.2299848673249), (3, 8, 706.6293229126569), (3, 6, 324.2344830520036), (3, 11, 462.0140690498505), (3, 9, 166.67633305301626), (3, 7, 623.4163937530036), (3, 5, 100.12492197250393), (3, 10, 379.14772846477666), (3, 1, 561.6021723604708), (3, 2, 96.87620966986684), (4, 8, 368.8807395351511), (4, 10, 75.66372975210778), (4, 11, 187.2671887971836), (4, 6, 556.9201019895044), (4, 5, 526.3430440311718), (4, 3, 426.2299848673249), (4, 1, 138.88484438555562), (4, 7, 203.8430768998545), (4, 9, 402.9900743194552), (4, 2, 331.1027030998086), (5, 2, 196.16319736382766), (5, 10, 478.60004178854814), (5, 1, 661.6358515074587), (5, 8, 798.9806005154318), (5, 11, 555.6005759536251), (5, 4, 526.3430440311718), (5, 3, 100.12492197250393), (5, 7, 722.9474393066207), (5, 9, 222.25210910135362), (5, 6, 332.8257802514703), (6, 3, 324.2344830520036), (6, 7, 753.7214339528895), (6, 5, 332.8257802514703), (6, 8, 667.0), (6, 10, 483.15318481823135), (6, 2, 360.8060420780118), (6, 4, 556.9201019895044), (6, 1, 654.3951405687545), (6, 9, 185.23768515072737), (6, 11, 469.847847712427), (7, 3, 623.4163937530036), (7, 8, 364.0673014704836), (7, 6, 753.7214339528895), (7, 9, 606.2878854141818), (7, 4, 203.8430768998545), (7, 1, 114.82595525402782), (7, 10, 272.21498856602295), (7, 2, 526.7988230814492), (7, 5, 722.9474393066207), (7, 11, 318.56710439089596), (8, 6, 667.0), (8, 5, 798.9806005154318), (8, 2, 629.5347488423495), (8, 4, 368.8807395351511), (8, 10, 360.6272313622475), (8, 3, 706.6293229126569), (8, 11, 244.9693858423946), (8, 7, 364.0673014704836), (8, 1, 276.99097458220547), (8, 9, 601.5064421932653), (9, 11, 368.40195439221003), (9, 1, 519.7172308092161), (9, 6, 185.23768515072737), (9, 7, 606.2878854141818), (9, 2, 178.04493814764857), (9, 8, 601.5064421932653), (9, 10, 335.574134879314), (9, 5, 222.25210910135362), (9, 3, 166.67633305301626), (9, 4, 402.9900743194552), (10, 6, 483.15318481823135), (10, 3, 379.14772846477666), (10, 4, 75.66372975210778), (10, 5, 478.60004178854814), (10, 1, 186.52613757862463), (10, 8, 360.6272313622475), (10, 9, 335.574134879314), (10, 11, 139.77839604173457), (10, 7, 272.21498856602295), (10, 2, 288.60006930006097), (11, 4, 187.2671887971836), (11, 1, 205.08047201037937), (11, 8, 244.9693858423946), (11, 10, 139.77839604173457), (11, 9, 368.40195439221003), (11, 7, 318.56710439089596), (11, 5, 555.6005759536251), (11, 6, 469.847847712427), (11, 2, 384.9623358200124), (11, 3, 462.0140690498505)] + # fmt:on + g = Graph(from_list=c) + d1, t1 = g.solve_tsp("bnb") + d2, t2 = g.solve_tsp("greedy") + assert d1 <= d2 or math.isclose(d1, d2), (d1, d2, g.edges()) + print(round(100 * ((d2 - d1) / d1)), "% greedy dist / bnb dist") + + +def test_cyclic_condition(): + """ + Below is a fully connected graph for this setup + + Lane 9 <--- locations: 60 & 70 <--- Lane 9 end + ^ ^ + | | + v v + Lane 10 ---> locations: 20...70 ---> Lane 10 end + ^ ^ + | | + v v + Lane 11 <--- locations 20...50 <--- Lane 11 end + """ + + # fmt:off + g = Graph( + from_dict={ + "10,20": {"10,20": 0, "10,30": 1, "10,40": 2, "10,50": 3, "11,30": 14, "18,30": 27, "11,50": 12, "11,40": 13, "11,20": 15, "10,60": 4, "10,70": 5, "9,70": 10, "9,60": 11}, + "10,30": {"10,20": 19, "10,30": 0, "10,40": 1, "10,50": 2, "11,30": 13, "18,30": 26, "11,50": 11, "11,40": 12, "11,20": 14, "10,60": 3, "10,70": 4, "9,70": 9, "9,60": 10}, + "10,40": {"10,20": 18, "10,30": 19, "10,40": 0, "10,50": 1, "11,30": 12, "18,30": 25, "11,50": 10, "11,40": 11, "11,20": 13, "10,60": 2, "10,70": 3, "9,70": 8, "9,60": 9}, + "10,50": {"10,20": 17, "10,30": 18, "10,40": 19, "10,50": 0, "11,30": 11, "18,30": 24, "11,50": 9, "11,40": 10, "11,20": 12, "10,60": 1, "10,70": 2, "9,70": 7, "9,60": 8}, + "11,30": {"10,20": 6, "10,30": 7, "10,40": 8, "10,50": 9, "11,30": 0, "18,30": 13, "11,50": 18, "11,40": 19, "11,20": 1, "10,60": 10, "10,70": 11, "9,70": 16, "9,60": 17}, + "18,30": {"10,20": 25, "10,30": 26, "10,40": 27, "10,50": 28, "11,30": 19, "18,30": 0, "11,50": 17, "11,40": 18, "11,20": 20, "10,60": 29, "10,70": 30, "9,70": 17, "9,60": 18}, + "11,50": {"10,20": 8, "10,30": 9, "10,40": 10, "10,50": 11, "11,30": 2, "18,30": 15, "11,50": 0, "11,40": 1, "11,20": 3, "10,60": 12, "10,70": 13, "9,70": 18, "9,60": 19}, + "11,40": {"10,20": 7, "10,30": 8, "10,40": 9, "10,50": 10, "11,30": 1, "18,30": 14, "11,50": 19, "11,40": 0, "11,20": 2, "10,60": 11, "10,70": 12, "9,70": 17, "9,60": 18}, + "11,20": {"10,20": 5, "10,30": 6, "10,40": 7, "10,50": 8, "11,30": 19, "18,30": 12, "11,50": 17, "11,40": 18, "11,20": 0, "10,60": 9, "10,70": 10, "9,70": 15, "9,60": 16}, + "10,60": {"10,20": 16, "10,30": 17, "10,40": 18, "10,50": 19, "11,30": 10, "18,30": 23, "11,50": 8, "11,40": 9, "11,20": 11, "10,60": 0, "10,70": 1, "9,70": 6, "9,60": 7}, + "10,70": {"10,20": 15, "10,30": 16, "10,40": 17, "10,50": 18, "11,30": 9, "18,30": 22, "11,50": 7, "11,40": 8, "11,20": 10, "10,60": 19, "10,70": 0, "9,70": 5, "9,60": 6}, + "9,70": {"10,20": 10, "10,30": 11, "10,40": 12, "10,50": 13, "11,30": 24, "18,30": 19, "11,50": 22, "11,40": 23, "11,20": 25, "10,60": 14, "10,70": 15, "9,70": 0, "9,60": 1}, + "9,60": {"10,20": 9, "10,30": 10, "10,40": 11, "10,50": 12, "11,30": 23, "18,30": 18, "11,50": 21, "11,40": 22, "11,20": 24, "10,60": 13, "10,70": 14, "9,70": 19, "9,60": 0}, + } + ) + # fmt:on + def exhaustive(g): + # d2, p2 = exhaustive() this takes 13 minutes to run, so here are the precomputed results: + # fmt:off + p2 = ("10,20", "10,30", "10,40", "10,50", "10,60", "10,70", "11,50", "11,40", "11,30", "11,20", "18,30", "9,70", "9,60") + # fmt:on + d2 = 54 + return d2, p2 + # The code below is here as documentation. + # assert isinstance(g, Graph) + # dm = g.all_pairs_shortest_paths() + # route = g.nodes() + # d2 = 999999999 + # for tour in itertools.permutations(route, len(route)): + # if tour[0] != route[0]: # all subsequent iterations are rotations of the first set. + # break + # tour += (tour[0],) + # d = sum(dm[a][b] for a,b in zip(tour[:-1], tour[1:])) + # if d < d2: + # d2 = d + # p2 = tour[:-1] + # return d2,p2 + + d2, p2 = exhaustive(g) + d1, p1 = g.solve_tsp() + """ + Running TSP before 2023 leads to the following oscillation + + V V V V + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,30', '18,30', '11,50', '11,40', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,40', '11,30', '18,30', '11,50', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,30', '18,30', '11,50', '11,40', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,40', '11,30', '18,30', '11,50', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,30', '18,30', '11,50', '11,40', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,40', '11,30', '18,30', '11,50', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,30', '18,30', '11,50', '11,40', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,40', '11,30', '18,30', '11,50', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,30', '18,30', '11,50', '11,40', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,40', '11,30', '18,30', '11,50', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,30', '18,30', '11,50', '11,40', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,40', '11,30', '18,30', '11,50', '11,20', '10,60', '10,70'] + ['9,70', '9,60', '10,20', '10,30', '10,40', '10,50', '11,30', '18,30', '11,50', '11,40', '11,20', '10,60', '10,70'] + """ + assert d1 == d2 + assert g.has_path(p2) + assert g.has_path(p1) + diff --git a/graph-theory/source/tests/test_visuals.py b/graph-theory/source/tests/test_visuals.py new file mode 100644 index 0000000000000000000000000000000000000000..0c9f7de7f9aa05ef33a758c1f44fa924dccecfeb --- /dev/null +++ b/graph-theory/source/tests/test_visuals.py @@ -0,0 +1,47 @@ +from graph.visuals import plot_2d +from graph import Graph + + +def test_bad_input(): + g = Graph(from_list=[ + (0, 1, 1), # 3 edges: + ]) + try: + _ = plot_2d(g) + raise AssertionError + except (ValueError, ImportError): + pass + + +def test_bad_input1(): + g = Graph(from_list=[ + ((1,), (0, 1), 1), + ]) + try: + _ = plot_2d(g) + raise AssertionError + except (ValueError, ImportError): + pass + + +def test_bad_input2(): + g = Graph(from_list=[ + ((1, 2), ('a', 'b'), 1), + ]) + try: + _ = plot_2d(g) + raise AssertionError + except (ValueError, ImportError): + pass + + +def test_bad_input3(): + g = Graph(from_list=[ + ((1, 'b'), ('b', 1), 1) + ]) + try: + _ = plot_2d(g) + raise AssertionError + except (ValueError, ImportError): + pass + diff --git a/graph-theory/source/tests/test_wtap.py b/graph-theory/source/tests/test_wtap.py new file mode 100644 index 0000000000000000000000000000000000000000..d539a3cb403371875e5942dba73db16b7bfbaba8 --- /dev/null +++ b/graph-theory/source/tests/test_wtap.py @@ -0,0 +1,256 @@ +from fractions import Fraction as F +from itertools import permutations, combinations_with_replacement +from random import random +from graph import Graph +from graph.assignment_problem import wtap_solver + + +def test_damage_assessment_calculation(): + g, weapons, target_values = wikipedia_wtap_setup() + + edges = [ + ("tank-0", 1, 0.3), + ("tank-1", 1, 0.3), + ("tank-2", 1, 0.3), + ("tank-3", 2, 0.2), + ("tank-4", 2, 0.2), + ("aircraft-0", 3, 0.5), + ("aircraft-1", 3, 0.5), + ("ship-0", 2, 0.5), + ] + assignment = Graph(from_list=edges) + assert 9.915 == wtap_damage_assessment(probabilities=g, assignment=assignment, target_values=target_values) + + +def test_basic_wtap(): + weapons = [1, 2, 3] + probabilities = [ + (1, 5, 0.1), + (1, 6, 0.1), + (1, 7, 0.1), + (2, 5, 0.1), + (2, 6, 0.1), + (2, 7, 0.1), + (3, 5, 0.1), + (3, 6, 0.1), + (3, 7, 0.1), + ] + target_values = {5: 5, 6: 6, 7: 7} + g = Graph(from_list=probabilities) + + value, assignments = wtap_solver(probabilities=g, weapons=weapons, target_values=target_values) + assert isinstance(assignments, Graph) + assert set(assignments.edges()) == {(2, 7, 0.1), (3, 6, 0.1), (1, 7, 0.1)} + assert value == 16.07 + + +def test_wtap_with_fractional_probabilities(): + weapons = [1, 2, 3] + probabilities = [ + (1, 5, F(1, 10)), + (1, 6, F(1, 10)), + (1, 7, F(1, 10)), + (2, 5, F(1, 10)), + (2, 6, F(1, 10)), + (2, 7, F(1, 10)), + (3, 5, F(1, 10)), + (3, 6, F(1, 10)), + (3, 7, F(1, 10)), + ] + target_values = {5: 5, 6: 6, 7: 7} + g = Graph(from_list=probabilities) + + value, assignments = wtap_solver(probabilities=g, weapons=weapons, target_values=target_values) + assert isinstance(assignments, Graph) + assert set(assignments.edges()) == {(2, 7, F(1, 10)), (3, 6, F(1, 10)), (1, 7, F(1, 10))} + assert float(value) == 16.07 + + +def test_exhaust_all_initialisation_permutations(): + """Uses the wikipedia WTAP setup.""" + g, weapons, target_values = wikipedia_wtap_setup() + + perfect_score = 4.95 + quality_score = 0 + quality_required = 0.97 + + variations = {} + damages = {} + perms = set(permutations(weapons, len(weapons))) + + c = 0 + while perms: + perm = perms.pop() + perm2 = tuple(reversed(perm)) + perms.remove(perm2) + + if random() < 0.5: + continue # skip 50 % of tests at random. + + damage1, ass1 = wtap_solver(probabilities=g, weapons=list(perm), target_values=target_values) + damage2, ass2 = wtap_solver(probabilities=g, weapons=list(perm2), target_values=target_values) + + damage_n = min(damage1, damage2) + if damage1 == damage_n: + assignment = ass1 + else: + assignment = ass2 + + damage = wtap_damage_assessment(probabilities=g, assignment=assignment, target_values=target_values) + assert round(damage_n, 2) == round(damage, 2) + damage = round(damage, 2) + + quality_score += damage + c += 1 + + if damage not in damages: + s = "{:.3f} : {}".format(damage, wikipedia_wtap_pretty_printer(assignment)) + damages[damage] = s + if damage not in variations: + variations[damage] = 1 + else: + variations[damage] += 1 + + print("tested", c, "permutations. Found", len(damages), "variation(s)") + if len(variations) > 1: + for k, v in sorted(damages.items()): + print(k, "frq: {}".format(variations[k])) + + solution_quality = perfect_score * c / quality_score + if solution_quality >= quality_required: + raise AssertionError("achieved {:.0f}%".format(solution_quality * 100)) + print("achieved {:.0f}%".format(solution_quality * 100)) + + +def test_exhaustive_search_to_verify_wtap(): + """Uses the wikipedia WTAP setup.""" + g, weapons, target_values = wikipedia_wtap_setup() + + best_result = sum(target_values.values()) + 1 + best_assignment = None + c = 0 + for perm in permutations(weapons, len(weapons)): + for combination in combinations_with_replacement([1, 2, 3], len(weapons)): + edges = [(w, t, g.edge(w, t)) for w, t in zip(perm, combination)] + a = Graph(from_list=edges) + r = wtap_damage_assessment(probabilities=g, assignment=a, target_values=target_values) + if r < best_result: + best_result = r + best_assignment = edges + c += 1 + print("{} is best result out of {:,} options(exhaustive search):\n{}".format(best_result, c, best_assignment)) + assert best_result == 4.95, best_result + + +def wikipedia_wtap_setup(): + """ + A commander has 5 tanks, 2 aircraft and 1 sea vessel and is told to + engage 3 targets with values 5,10,20 ... + """ + tanks = ["tank-{}".format(i) for i in range(5)] + aircrafts = ["aircraft-{}".format(i) for i in range(2)] + ships = ["ship-{}".format(i) for i in range(1)] + weapons = tanks + aircrafts + ships + target_values = {1: 5, 2: 10, 3: 20} + + tank_probabilities = [ + (1, 0.3), + (2, 0.2), + (3, 0.5), + ] + + aircraft_probabilities = [ + (1, 0.1), + (2, 0.6), + (3, 0.5), + ] + + sea_vessel_probabilities = [(1, 0.4), (2, 0.5), (3, 0.4)] + + category_and_probabilities = [ + (tanks, tank_probabilities), + (aircrafts, aircraft_probabilities), + (ships, sea_vessel_probabilities), + ] + + probabilities = [] + for category, probs in category_and_probabilities: + for vehicle in category: + for prob in probs: + probabilities.append((vehicle,) + prob) + + g = Graph(from_list=probabilities) + return g, weapons, target_values + + +def wtap_damage_assessment(probabilities, assignment, target_values): + """ + :param probabilities: graph. + :param assignment: graph + :param target_values: dictionary + :return: total survival value of the targets. + """ + assert isinstance(probabilities, Graph) + assert isinstance(assignment, Graph) + result = assignment.edges() + assert isinstance(target_values, dict) + + survival_value = {} + for item in result: + weapon, target, damage = item + if target not in survival_value: + survival_value[target] = {} + wtype = weapon.split("-")[0] + if wtype not in survival_value[target]: + survival_value[target][wtype] = 0 + survival_value[target][wtype] += 1 + + total_survival_value = 0 + for target, assigned_weapons in survival_value.items(): + p = 1 + for wtype, quantity in assigned_weapons.items(): + weapon = wtype + "-0" + p_base = 1 - probabilities.edge(weapon, target) + p *= p_base**quantity + + total_survival_value += p * target_values[target] + + for target in target_values: + if target not in survival_value: + total_survival_value += target_values[target] + + return total_survival_value + + +def wikipedia_wtap_pretty_printer(assignment): + """Produces a human readable print out of the assignment + :param assignment: graph + :return: str + """ + assert isinstance(assignment, Graph) + result = assignment.edges() + survival_value = {} + for item in result: + weapon, target, damage = item + if target not in survival_value: + survival_value[target] = {} + wtype = weapon.split("-")[0] + if wtype not in survival_value[target]: + survival_value[target][wtype] = 0 + survival_value[target][wtype] += 1 + + lines = [] + for target, wtypes in sorted(survival_value.items()): + lines.append("T-{}: ".format(target)) + _and = " + " + for wtype, qty in sorted(wtypes.items()): + if qty > 1: + _wtype = wtype + "s" + else: + _wtype = wtype + lines.append("{} {}".format(qty, _wtype)) + lines.append(_and) + lines.pop(-1) + lines.append(", ") + s = "".join(lines) + return s diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..6c9b423f94d26e6f7cf9f9f0d4ba6301249a7f78 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastmcp +fastapi +uvicorn[standard] +pydantic>=2.0.0 +numpy +scipy diff --git a/run_docker.ps1 b/run_docker.ps1 new file mode 100644 index 0000000000000000000000000000000000000000..c38313cf2d9d4033a928cae6b1e53d62d560349f --- /dev/null +++ b/run_docker.ps1 @@ -0,0 +1,35 @@ +cd $PSScriptRoot + +$ErrorActionPreference = "Stop" + +$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "graph-theory" } +$entryUrl = if ($env:MCP_ENTRY_URL) { $env:MCP_ENTRY_URL } else { "http://localhost:7860/mcp" } +$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "graph-theory-mcp" } + +$mcpDir = Join-Path $env:USERPROFILE ".cursor" +$mcpPath = Join-Path $mcpDir "mcp.json" +if (!(Test-Path $mcpDir)) { New-Item -ItemType Directory -Path $mcpDir | Out-Null } + +$config = @{} +if (Test-Path $mcpPath) { + try { $config = Get-Content $mcpPath -Raw | ConvertFrom-Json } catch { $config = @{} } +} + +# Rebuild mcpServers as ordered and append the entry last +$serversOrdered = [ordered]@{} +if ($config -and ($config.PSObject.Properties.Name -contains "mcpServers") -and $config.mcpServers) { + $existing = $config.mcpServers + if ($existing -is [pscustomobject]) { + foreach ($p in $existing.PSObject.Properties) { if ($p.Name -ne $entryName) { $serversOrdered[$p.Name] = $p.Value } } + } elseif ($existing -is [System.Collections.IDictionary]) { + foreach ($k in $existing.Keys) { if ($k -ne $entryName) { $serversOrdered[$k] = $existing[$k] } } + } +} +$serversOrdered[$entryName] = @{ url = $entryUrl } +$config = @{ mcpServers = $serversOrdered } + +$config | ConvertTo-Json -Depth 10 | Set-Content -Path $mcpPath -Encoding UTF8 +Write-Host ("Updated $entryName in " + $mcpPath + " -> " + $entryUrl) + +docker build -t $imageName . +docker run --rm -p 7860:7860 $imageName diff --git a/run_docker.sh b/run_docker.sh new file mode 100644 index 0000000000000000000000000000000000000000..423258facf3bf207166808b7be0eab32207e474a --- /dev/null +++ b/run_docker.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +set -euo pipefail + +# Switch to the directory where this script is located +cd "$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)" + +mcp_entry_name="${MCP_ENTRY_NAME:-graph-theory}" +mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7860/mcp}" +mcp_dir="${HOME}/.cursor" +mcp_path="${mcp_dir}/mcp.json" +mkdir -p "${mcp_dir}" + +if command -v python3 >/dev/null 2>&1; then +python3 - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY' +import json, os, sys +path, name, url = sys.argv[1:4] +cfg = {"mcpServers": {}} +if os.path.exists(path): + try: + with open(path, "r", encoding="utf-8") as f: + cfg = json.load(f) + except Exception: + cfg = {"mcpServers": {}} +if not isinstance(cfg, dict): + cfg = {"mcpServers": {}} +servers = cfg.get("mcpServers") +if not isinstance(servers, dict): + servers = {} +ordered = {} +for k, v in servers.items(): + if k != name: + ordered[k] = v +ordered[name] = {"url": url} +cfg = {"mcpServers": ordered} +with open(path, "w", encoding="utf-8") as f: + json.dump(cfg, f, indent=2, ensure_ascii=False) +PY +elif command -v python >/dev/null 2>&1; then +python - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY' +import json, os, sys +path, name, url = sys.argv[1:4] +cfg = {"mcpServers": {}} +if os.path.exists(path): + try: + with open(path, "r", encoding="utf-8") as f: + cfg = json.load(f) + except Exception: + cfg = {"mcpServers": {}} +if not isinstance(cfg, dict): + cfg = {"mcpServers": {}} +servers = cfg.get("mcpServers") +if not isinstance(servers, dict): + servers = {} +ordered = {} +for k, v in servers.items(): + if k != name: + ordered[k] = v +ordered[name] = {"url": url} +cfg = {"mcpServers": ordered} +with open(path, "w", encoding="utf-8") as f: + json.dump(cfg, f, indent=2, ensure_ascii=False) +PY +elif command -v jq >/dev/null 2>&1; then + name="${mcp_entry_name}"; url="${mcp_entry_url}" + if [ -f "${mcp_path}" ]; then + tmp="$(mktemp)" + jq --arg name "$name" --arg url "$url" ' + .mcpServers = (.mcpServers // {}) + | .mcpServers as $s + | ($s | with_entries(select(.key != $name))) as $base + | .mcpServers = ($base + {($name): {"url": $url}}) + ' "${mcp_path}" > "${tmp}" && mv "${tmp}" "${mcp_path}" + else + printf '{ "mcpServers": { "%s": { "url": "%s" } } } +' "$name" "$url" > "${mcp_path}" + fi +else + echo "Warning: neither python nor jq found; skipped updating ~/.cursor/mcp.json" >&2 +fi + +docker build -t graph-theory-mcp . +docker run --rm -p 7860:7860 graph-theory-mcp